diff --git a/.github/workflows/bench-main.yml b/.github/workflows/bench-main.yml
index 65fff44c..b031059b 100644
--- a/.github/workflows/bench-main.yml
+++ b/.github/workflows/bench-main.yml
@@ -268,8 +268,10 @@ jobs:
     runs-on: warp-ubuntu-latest-x64-32x
     # `ix bench run` persists completed rows incrementally, so even a
     # job-level timeout keeps them on disk, but the bencher upload needs
-    # the job alive.
-    timeout-minutes: 60
+    # the job alive. The aiur pipeline now carries stage 3 (the KZG wrap:
+    # ~15 min and ~80 GiB per small constant at 40 queries, measured),
+    # on top of stages 1-2 — hence the wider budget.
+    timeout-minutes: 120
     strategy:
       fail-fast: false
       matrix:
diff --git a/.github/workflows/bench-pr.yml b/.github/workflows/bench-pr.yml
index dd818d4b..3708f324 100644
--- a/.github/workflows/bench-pr.yml
+++ b/.github/workflows/bench-pr.yml
@@ -35,7 +35,9 @@
 # Each backend runs its registry default mode:
 #   - aiur: `prove` — the full proof pipeline per constant (stage 1
 #     proves the IxVM typecheck, stage 2 executes and proves the
-#     in-circuit multi-stark verifier over that fresh proof), reported
+#     in-circuit multi-stark verifier over that fresh proof, stage 3
+#     proves the foreign verifier's acceptance of the stage-2 proof over
+#     BLS12-381 under KZG — the natively-verified wrap), reported
 #     as one comparison table per stage — witness execute, prove, peak
 #     RAM, proof size, verify — closing with the pipeline ledger (total
 #     time and the run's RAM ceiling). Its default selection is a fixed
@@ -470,8 +472,11 @@ jobs:
     if: ${{ !cancelled() && needs.build.result == 'success' && needs.compile.result != 'failure' && needs.compile.result != 'cancelled' }}
     runs-on: ${{ matrix.params.runner }}
     # `ix bench run` saves completed rows as it goes, so a timeout keeps
-    # them on disk — but the compare and upload need the job alive.
-    timeout-minutes: 60
+    # them on disk — but the compare and upload need the job alive. The
+    # aiur pipeline carries stage 3 (the KZG wrap, ~15 min and ~80 GiB per
+    # small constant at 40 queries) on top of stages 1-2, and a PR run
+    # measures both sides — hence the wider budget.
+    timeout-minutes: 120
     strategy:
       fail-fast: false
       matrix:
diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean
index 15684836..1881377e 100644
--- a/Benchmarks/Typecheck.lean
+++ b/Benchmarks/Typecheck.lean
@@ -205,6 +205,19 @@ structure Result where
   /-- Wall time of `AiurSystem.verify` over the outer proof; `none` if that
       verification failed (reported loudly). -/
   recursiveVerifySec : Option Float := none
+  /-- Stage 3 (`--kzg` only): wall time of proving the FOREIGN (byte-limb)
+      verifier's acceptance of the stage-2 proof over the BLS12-381 scalar
+      field under the KZG backend — execution (generic Fr interpreter),
+      witness, commitments, and opening in one span. -/
+  kzgProveSec : Option Float := none
+  /-- The stage-3 prove's RSS high-water (windowed like the other peaks). -/
+  kzgPeakRss : Option Nat := none
+  /-- Serialized stage-3 (KZG) proof size in bytes — Θ(circuit width),
+      constant in trace height. -/
+  kzgProofSize : Option Nat := none
+  /-- Wall time of the NATIVE stage-3 verification (two pairings);
+      `none` if it failed (reported loudly). -/
+  kzgVerifySec : Option Float := none
   deriving Inhabited
 
 /-- A `Json` number with at most `d` decimal places, rendered decimally.
@@ -228,7 +241,8 @@ def jsonRound (d : Nat) (f : Float) : Json :=
     constants/sec over the prove. The two modes store on separate bencher
     testbeds (aiur-execute-* / aiur-*), so the shared names never
     collide — run the execute run when you want execute-side numbers. -/
-def Result.toJsonEntry (executeOnly : Bool) (r : Result) : String × Json :=
+def Result.toJsonEntry (executeOnly : Bool) (kzg : Bool) (r : Result) :
+    String × Json :=
   if r.failed then
     (r.name, Json.mkObj [("status", Json.str "rejected")]) else
   let base : List (String × Json) :=
@@ -279,6 +293,19 @@ def Result.toJsonEntry (executeOnly : Bool) (r : Result) : String × Json :=
     let fields := match r.recursiveVerifySec with
       | some v => fields ++ [ ("recursive-verify-time", jsonRound 6 v) ]
       | none => fields
+    -- The stage-3 (KZG wrap) metrics, in measurement order.
+    let fields := match r.kzgProveSec with
+      | some s => fields ++ [ ("kzg-prove-time", jsonRound 6 s) ]
+      | none => fields
+    let fields := match r.kzgPeakRss with
+      | some n => fields ++ [ ("kzg-peak-rss", Lean.toJson n) ]
+      | none => fields
+    let fields := match r.kzgProofSize with
+      | some n => fields ++ [ ("kzg-proof-size", Lean.toJson n) ]
+      | none => fields
+    let fields := match r.kzgVerifySec with
+      | some v => fields ++ [ ("kzg-verify-time", jsonRound 6 v) ]
+      | none => fields
     -- The pipeline ledger, once the whole pipeline has run.
     -- `total-time` is each stage's prove, summed. A stage's prove is
     -- the WHOLE cost of producing that stage's proof: `prove_ixvm` runs
@@ -293,13 +320,19 @@ def Result.toJsonEntry (executeOnly : Bool) (r : Result) : String × Json :=
     -- RAM does this pipeline need" — their maximum does. Emitted
     -- only with every component present, so it doubles as the row's
     -- completion marker (the orchestrator's teardown-kill `doneKey`).
+    -- Under `--kzg` the pipeline includes stage 3, so the ledger (and the
+    -- completion marker it doubles as) additionally requires the wrap.
+    let stage3Done := !kzg || r.kzgProveSec.isSome
     let fields := match r.proveSec, r.recursiveExecuteSec, r.recursiveProveSec with
       | some p, some _, some rp =>
-        let peaks := [r.executePeakRss, r.peakRss, r.recursivePeakRss].reduceOption
-        fields ++ [ ("total-time", jsonRound 6 (p + rp)) ]
-          ++ (match peaks.max? with
-              | some n => [("pipeline-peak-rss", Lean.toJson n)]
-              | none => [])
+        if stage3Done then
+          let peaks := [r.executePeakRss, r.peakRss, r.recursivePeakRss,
+                        r.kzgPeakRss].reduceOption
+          fields ++ [ ("total-time", jsonRound 6 (p + rp + (r.kzgProveSec.getD 0))) ]
+            ++ (match peaks.max? with
+                | some n => [("pipeline-peak-rss", Lean.toJson n)]
+                | none => [])
+        else fields
       | _, _, _ => fields
     (r.name, Json.mkObj fields)
 
@@ -336,6 +369,14 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
   if recursive && executeOnly then
     IO.eprintln "error: --recursive measures the prove path; drop --execute-only"
     return Ix.Benchmark.Results.exitUsage
+  -- KZG (stage 3): after each constant's stage-2 (outer) prove, wrap THAT
+  -- proof — prove the foreign verifier's acceptance of it over the
+  -- BLS12-381 scalar field under the KZG backend, and verify natively.
+  let kzg := p.hasFlag "kzg"
+  if kzg && !recursive then
+    IO.eprintln "error: --kzg wraps the stage-2 proof; it requires --recursive"
+    return Ix.Benchmark.Results.exitUsage
+  let kzgLogSrs := ((p.flag? "kzg-log-srs").map (·.as! Nat)).getD 23
   -- Off by default; CI passes --texray explicitly.
   let useTexray := p.hasFlag "texray"
   let useInterp := p.hasFlag "interp"
@@ -394,6 +435,25 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
         | throw (IO.userError "verify_multi_stark_proof entrypoint missing")
       pure (some (vCompiled, vIdx,
         Aiur.AiurSystem.build vCompiled.bytecode commitParams friParams))
+  -- The stage-3 context, also constant-independent and built ONCE: the
+  -- FOREIGN (byte-limb) verifier toplevel over the BLS12-381 scalar field
+  -- under the KZG backend. Dev-grade SRS of size 2^kzgLogSrs (see
+  -- `AiurKzgSystem.build`); the setup itself is timed and reported since
+  -- it is minutes-scale at 2^20.
+  let kzgCtx : Option (Aiur.Bytecode.FunIdx × Aiur.AiurKzgSystem) ←
+    if !kzg then pure none else do
+      let .ok fTop := MultiStark.multiStarkForeign
+        | throw (IO.userError "Merging foreign multi-stark verifier failed")
+      let .ok fCompiled := fTop.compile
+        | throw (IO.userError "Compilation of foreign multi-stark verifier failed")
+      let some fIdx := fCompiled.getFuncIdx `verify_multi_stark_proof
+        | throw (IO.userError "foreign verify_multi_stark_proof entrypoint missing")
+      IO.println s!"building KZG system (dev SRS 2^{kzgLogSrs}) …"
+      (← IO.getStdout).flush
+      let (kzgSystem, srsSec) ← timed fun _ =>
+        Aiur.AiurKzgSystem.build fCompiled.bytecode kzgLogSrs 4
+      IO.println s!"KZG system ready ({srsSec}s)"
+      pure (some (fIdx, kzgSystem))
 
   -- Load the serialized env lazily (the `ix check --ixe` path, #445): byte-window
   -- constants over the backing buffer, so only the checked closure is ever
@@ -494,7 +554,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
     match jsonOut with
     | some path =>
       results.forM fun r =>
-        let (name, row) := Result.toJsonEntry executeOnly r
+        let (name, row) := Result.toJsonEntry executeOnly kzg r
         Ix.Benchmark.Results.writeEntry path name row
     | none => pure ()
 
@@ -635,6 +695,38 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
                         , recursiveProofSize := some rvProofBytes.size
                         , recursiveVerifySec := rvVerifySec? }, addr)
             writeJson (ordered.map (·.1))
+            -- Stage 3 (--kzg): wrap the fresh stage-2 proof — prove the
+            -- FOREIGN verifier's acceptance of it over the BLS12-381
+            -- scalar field under the KZG backend, then verify natively
+            -- (two pairings). The stage-2 proof plays the role its
+            -- stage-1 proof played for stage 2: advice bytes, with the
+            -- stage-2 vk and claim digest-bound as the public input.
+            if let some (kIdx, kzgSystem) := kzgCtx then
+              IO.println s!"  [{i + 1}/{ordered.size}] KZG-wrapping {r.name}'s stage-2 proof …"
+              (← IO.getStdout).flush
+              TracingTexray.resetPeakTreeRss
+              let s2ClaimBytes := MultiStark.serializeClaims #[rvClaim]
+              let s2VkBytes := vSystem.vkBytes
+              let s2PubInput := MultiStark.verifierPubInput s2VkBytes s2ClaimBytes
+              let ((wClaim, wBytes), kSec) ← timed fun _ =>
+                kzgSystem.proveMultiStark kIdx s2PubInput rvProofBytes
+                  s2VkBytes s2ClaimBytes
+              let kPeak ← TracingTexray.peakTreeRssBytes
+              let (kvRes, kvSec) ← timed fun _ => kzgSystem.verify wClaim wBytes
+              let kvSec? ← match kvRes with
+                | .ok () => pure (some kvSec)
+                | .error e =>
+                  IO.eprintln s!"  KZG verify {r.name} FAILED: {e}"
+                  pure none
+              IO.println s!"  {r.name}: kzg-prove={kSec}s kzg-verify={kvSec}s \
+                kzg proof={wBytes.size} bytes"
+              let (row, _) := ordered[i]!
+              ordered := ordered.set! i
+                ({ row with kzgProveSec := some kSec
+                          , kzgPeakRss := some kPeak
+                          , kzgProofSize := some wBytes.size
+                          , kzgVerifySec := kvSec? }, addr)
+              writeJson (ordered.map (·.1))
     catch e =>
       IO.eprintln s!"  prove {r.name} threw: {e}"
 
@@ -655,6 +747,8 @@ def typecheckCmd : Cli.Cmd := `[Cli|
     "skip-deps";          "Check only each target itself (verify_const, trusting its deps) instead of re-checking its whole transitive closure (verify_claim). Same flag as `zisk-host --skip-deps`."
     "execute-only";       "Execute only (Phase 1: constants / fft-cost / execute-time) and skip proving. The fast per-PR `execute`-mode signal."
     "recursive";          "After each prove, execute and then prove the in-circuit multi-stark verifier over the fresh proof (the recursive-* metrics; see the module docstring). Uses recursion-tuned FRI parameters. Conflicts with --execute-only."
+    "kzg";                "Stage 3: after each stage-2 (outer) prove, wrap that proof — prove the FOREIGN (byte-limb) verifier's acceptance of it over the BLS12-381 scalar field under the KZG backend, verify natively (the kzg-* metrics). Requires --recursive. Dev-grade SRS."
+    "kzg-log-srs" : Nat;  "log2 of the dev SRS size for --kzg (default 23 — headroom over the ~2^22 tallest stage-3 trace at kernel scale; must be at least the tallest stage-3 trace height)."
     "interp";             "Route execution through the generic Aiur bytecode interpreter instead of the codegen'd IxVM kernel - no `lake exe ix codegen` + cargo rebuild needed after `Ix/IxVM/*.lean` edits. Applies to Phase 1, the prove's witness generation, and both --recursive steps. Slower; execute-time rows are not comparable to codegen-mode runs (fft-cost is)."
     "queries"   : Nat;    "Override the FRI query count of the selected parameter set (default 100, or 50 with --recursive; applies to inner and outer proof alike)."
     texray;               "Enable the tracing-texray timeline + RAM breakdown (per-prove spans on stderr). Combined with --json, per-phase span timings are additionally written to `<json>.spans` as JSON Lines for the CI drill-down. Off by default."
diff --git a/Cargo.lock b/Cargo.lock
index 90750c4c..c8a8d912 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -37,6 +37,18 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -91,6 +103,136 @@ dependencies = [
  "object",
 ]
 
+[[package]]
+name = "ark-bls12-381"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3df4dcc01ff89867cd86b0da835f23c3f02738353aaee7dde7495af71363b8d5"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+]
+
+[[package]]
+name = "ark-ec"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d68f2d516162846c1238e755a7c4d131b892b70cc70c471a8e3ca3ed818fce"
+dependencies = [
+ "ahash",
+ "ark-ff",
+ "ark-poly",
+ "ark-serialize",
+ "ark-std",
+ "educe",
+ "fnv",
+ "hashbrown 0.15.5",
+ "itertools 0.13.0",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "rayon",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a177aba0ed1e0fbb62aa9f6d0502e9b46dad8c2eab04c14258a1212d2557ea70"
+dependencies = [
+ "ark-ff-asm",
+ "ark-ff-macros",
+ "ark-serialize",
+ "ark-std",
+ "arrayvec",
+ "digest 0.10.7",
+ "educe",
+ "itertools 0.13.0",
+ "num-bigint",
+ "num-traits",
+ "paste",
+ "rayon",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff-asm"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62945a2f7e6de02a31fe400aa489f0e0f5b2502e69f95f853adb82a96c7a6b60"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "ark-ff-macros"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09be120733ee33f7693ceaa202ca41accd5653b779563608f1234f78ae07c4b3"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "ark-poly"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "579305839da207f02b89cd1679e50e67b4331e2f9294a57693e5051b7703fe27"
+dependencies = [
+ "ahash",
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+ "educe",
+ "fnv",
+ "hashbrown 0.15.5",
+ "rayon",
+]
+
+[[package]]
+name = "ark-serialize"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f4d068aaf107ebcd7dfb52bc748f8030e0fc930ac8e360146ca54c1203088f7"
+dependencies = [
+ "ark-serialize-derive",
+ "ark-std",
+ "arrayvec",
+ "digest 0.10.7",
+ "num-bigint",
+ "rayon",
+]
+
+[[package]]
+name = "ark-serialize-derive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "213888f660fddcca0d257e88e54ac05bca01885f258ccdf695bafd77031bb69d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "246a225cc6131e9ee4f24619af0f19d67761fff15d7ccc22e42b80846e69449a"
+dependencies = [
+ "num-traits",
+ "rand 0.8.7",
+ "rayon",
+]
+
 [[package]]
 name = "arrayref"
 version = "0.3.9"
@@ -111,7 +253,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -232,7 +374,7 @@ dependencies = [
  "regex",
  "rustc-hash",
  "shlex",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -528,7 +670,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -552,7 +694,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -563,7 +705,7 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
  "darling_core",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -625,7 +767,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -635,7 +777,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
 dependencies = [
  "derive_builder_core",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -657,7 +799,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustc_version",
- "syn",
+ "syn 2.0.117",
  "unicode-xid",
 ]
 
@@ -708,7 +850,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -758,6 +900,18 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "educe"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7bc049e1bd8cdeb31b68bbd586a9464ecf9f3944af3958a7a9d0f8b9799417"
+dependencies = [
+ "enum-ordinalize",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -785,7 +939,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -796,7 +950,27 @@ checksum = "3ed8956bd5c1f0415200516e78ff07ec9e16415ade83c056c230d7b7ea0d55b7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "enum-ordinalize"
+version = "4.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89dd01549b09589510cf0647475075d12071456586d70f5c75c98ae2a5537677"
+dependencies = [
+ "enum-ordinalize-derive",
+]
+
+[[package]]
+name = "enum-ordinalize-derive"
+version = "4.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a65863d15a4ce2888bd2f0f543cc963d3879c3a022c8ee43f6141d479a3ac815"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
 ]
 
 [[package]]
@@ -974,7 +1148,7 @@ checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1667,7 +1841,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2084,9 +2258,15 @@ dependencies = [
 [[package]]
 name = "multi-stark"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=c72d32130eb084327b73849e39c92734a8829011#c72d32130eb084327b73849e39c92734a8829011"
+source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=4ffbd47#4ffbd47a62cf054b15fc46391b2db8196508390c"
 dependencies = [
+ "ark-bls12-381",
+ "ark-ec",
+ "ark-ff",
+ "ark-poly",
+ "ark-serialize",
  "bincode",
+ "blake3",
  "p3-air",
  "p3-blake3",
  "p3-challenger",
@@ -2123,7 +2303,7 @@ checksum = "03755949235714b2b307e5ae89dd8c1c2531fb127d9b8b7b4adf9c876cd3ed18"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2412,7 +2592,7 @@ dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2844,7 +3024,7 @@ checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2968,7 +3148,7 @@ checksum = "e0232bd009a197ceec9cc881ba46f727fcd8060a2d8d6a9dde7a69030a6fe2bb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3002,7 +3182,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3061,7 +3241,7 @@ checksum = "a9a28b8493dd664c8b171dd944da82d933f7d456b829bfb236738e1fe06c5ba4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3140,13 +3320,23 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
+[[package]]
+name = "rand"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f6172bdec972074665ed81ed53b71da00bfc44b65a753cfde883ec4c702a1a"
+dependencies = [
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
 [[package]]
 name = "rand"
 version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
 dependencies = [
- "rand_chacha",
+ "rand_chacha 0.9.0",
  "rand_core 0.9.5",
 ]
 
@@ -3160,6 +3350,16 @@ dependencies = [
  "rand_core 0.10.1",
 ]
 
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
 [[package]]
 name = "rand_chacha"
 version = "0.9.0"
@@ -3170,6 +3370,12 @@ dependencies = [
  "rand_core 0.9.5",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
 [[package]]
 name = "rand_core"
 version = "0.9.5"
@@ -3457,7 +3663,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3595,7 +3801,7 @@ checksum = "c87e960f4dca2788eeb86bbdde8dd246be8948790b7618d656e68f9b720a86e8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3675,7 +3881,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3695,6 +3901,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
 [[package]]
 name = "sync_wrapper"
 version = "1.0.2"
@@ -3712,7 +3929,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3748,7 +3965,7 @@ checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3852,7 +4069,7 @@ checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4008,7 +4225,7 @@ checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4295,7 +4512,7 @@ dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
  "wasm-bindgen-shared",
 ]
 
@@ -4465,7 +4682,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4476,7 +4693,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4669,7 +4886,7 @@ dependencies = [
  "heck",
  "indexmap",
  "prettyplease",
- "syn",
+ "syn 2.0.117",
  "wasm-metadata",
  "wit-bindgen-core",
  "wit-component",
@@ -4685,7 +4902,7 @@ dependencies = [
  "prettyplease",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
  "wit-bindgen-core",
  "wit-bindgen-rust",
 ]
@@ -4801,7 +5018,7 @@ checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
  "synstructure",
 ]
 
@@ -4828,7 +5045,7 @@ checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4848,7 +5065,7 @@ checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
  "synstructure",
 ]
 
@@ -4869,7 +5086,7 @@ checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4902,7 +5119,7 @@ checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 7281dfe7..242adb10 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -56,7 +56,7 @@ libc = "0.2"
 log = "0.4"
 memmap2 = "0.9"
 mimalloc = { version = "0.1", default-features = false }
-multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "c72d32130eb084327b73849e39c92734a8829011" }
+multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "4ffbd47" }
 nom = "7.1.3"
 num-bigint = "0.4.6"
 quickcheck = "1.0.3"
diff --git a/Ix/Aiur/Compiler/Check.lean b/Ix/Aiur/Compiler/Check.lean
index ca0739f8..4ec8eac1 100644
--- a/Ix/Aiur/Compiler/Check.lean
+++ b/Ix/Aiur/Compiler/Check.lean
@@ -818,7 +818,7 @@ def inferTerm (t : Term) : CheckM Typed.Term := match t with
     pure (Typed.Term.u32ToField .field false a')
   | .u8Lit n => do
     if n ≥ 256 then throw (.u8LitOutOfRange n)
-    pure (Typed.Term.field .u8 false (G.ofNat n))
+    pure (Typed.Term.field .u8 false n)
   | .u8RangeCheck a b => do
     let a' ← checkNoEscape a .field
     let b' ← checkNoEscape b .field
@@ -839,6 +839,12 @@ def inferTerm (t : Term) : CheckM Typed.Term := match t with
   | .unconstrainedGInverse a => do
     let a' ← checkNoEscape a .field
     pure (Typed.Term.unconstrainedGInverse .field false a')
+  | .unconstrainedGlDivMod a => do
+    let a' ← checkNoEscape a .field
+    pure (Typed.Term.unconstrainedGlDivMod (.tuple #[.field, .field]) false a')
+  | .unconstrainedGlInverse a => do
+    let a' ← checkNoEscape a .field
+    pure (Typed.Term.unconstrainedGlInverse .field false a')
   | .toField a => do
     let a' ← checkNoEscape a .u8
     pure (Typed.Term.toField .field false a')
@@ -1024,6 +1030,10 @@ def zonkTypedTerm (t : Typed.Term) : CheckM Typed.Term := match t with
       pure (.unconstrainedGToBytes (← zonkTyp τ) e (← zonkTypedTerm a))
   | .unconstrainedGInverse τ e a => do
       pure (.unconstrainedGInverse (← zonkTyp τ) e (← zonkTypedTerm a))
+  | .unconstrainedGlDivMod τ e a => do
+      pure (.unconstrainedGlDivMod (← zonkTyp τ) e (← zonkTypedTerm a))
+  | .unconstrainedGlInverse τ e a => do
+      pure (.unconstrainedGlInverse (← zonkTyp τ) e (← zonkTypedTerm a))
   | .unconstrainedU32Add τ e a b => do
       pure (.unconstrainedU32Add (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
   | .unconstrainedU32Add3 τ e a b c => do
diff --git a/Ix/Aiur/Compiler/Concretize.lean b/Ix/Aiur/Compiler/Concretize.lean
index 9ff782f1..b4d836df 100644
--- a/Ix/Aiur/Compiler/Concretize.lean
+++ b/Ix/Aiur/Compiler/Concretize.lean
@@ -379,6 +379,10 @@ def termToConcrete
       pure (.unconstrainedGToBytes (← typToConcrete mono τ) e (← termToConcrete mono a))
   | .unconstrainedGInverse τ e a => do
       pure (.unconstrainedGInverse (← typToConcrete mono τ) e (← termToConcrete mono a))
+  | .unconstrainedGlDivMod τ e a => do
+      pure (.unconstrainedGlDivMod (← typToConcrete mono τ) e (← termToConcrete mono a))
+  | .unconstrainedGlInverse τ e a => do
+      pure (.unconstrainedGlInverse (← typToConcrete mono τ) e (← termToConcrete mono a))
   -- `toField` / `u8FromFieldUnsafe` are erased coercions: `u8` and `field`
   -- share a representation, so we drop the wrapper and keep the inner term.
   | .toField _ _ a | .u8FromFieldUnsafe _ _ a => termToConcrete mono a
@@ -599,6 +603,10 @@ def rewriteTypedTerm (decls : Typed.Decls)
       (rewriteTypedTerm decls subst mono a)
   | .unconstrainedGInverse τ e a => .unconstrainedGInverse (rewriteTyp subst mono τ) e
       (rewriteTypedTerm decls subst mono a)
+  | .unconstrainedGlDivMod τ e a => .unconstrainedGlDivMod (rewriteTyp subst mono τ) e
+      (rewriteTypedTerm decls subst mono a)
+  | .unconstrainedGlInverse τ e a => .unconstrainedGlInverse (rewriteTyp subst mono τ) e
+      (rewriteTypedTerm decls subst mono a)
   | .toField τ e a => .toField (rewriteTyp subst mono τ) e
       (rewriteTypedTerm decls subst mono a)
   | .u8FromFieldUnsafe τ e a => .u8FromFieldUnsafe (rewriteTyp subst mono τ) e
@@ -680,6 +688,7 @@ def collectInTypedTerm (seen : Std.HashSet (Global × Array Typ)) :
   | .eqZero τ _ a | .store τ _ a | .load τ _ a | .ptrVal τ _ a | .toField τ _ a
   | .u8FromFieldUnsafe τ _ a
   | .unconstrainedGToBytes τ _ a | .unconstrainedGInverse τ _ a
+  | .unconstrainedGlDivMod τ _ a | .unconstrainedGlInverse τ _ a
   | .u32ToField τ _ a
   | .u8BitDecomposition τ _ a | .u8ShiftLeft τ _ a | .u8ShiftRight τ _ a =>
     collectInTypedTerm (collectInTyp seen τ) a
@@ -755,6 +764,7 @@ def collectCalls (decls : Typed.Decls)
   | .eqZero _ _ a | .store _ _ a | .load _ _ a | .ptrVal _ _ a | .toField _ _ a
   | .u8FromFieldUnsafe _ _ a
   | .unconstrainedGToBytes _ _ a | .unconstrainedGInverse _ _ a
+  | .unconstrainedGlDivMod _ _ a | .unconstrainedGlInverse _ _ a
   | .u32ToField _ _ a
   | .u8BitDecomposition _ _ a | .u8ShiftLeft _ _ a | .u8ShiftRight _ _ a =>
     collectCalls decls seen a
@@ -880,6 +890,10 @@ def substInTypedTerm (subst : Global → Option Typ) : Typed.Term → Typed.Term
     .unconstrainedGToBytes (Typ.instantiate subst τ) e (substInTypedTerm subst a)
   | .unconstrainedGInverse τ e a =>
     .unconstrainedGInverse (Typ.instantiate subst τ) e (substInTypedTerm subst a)
+  | .unconstrainedGlDivMod τ e a =>
+    .unconstrainedGlDivMod (Typ.instantiate subst τ) e (substInTypedTerm subst a)
+  | .unconstrainedGlInverse τ e a =>
+    .unconstrainedGlInverse (Typ.instantiate subst τ) e (substInTypedTerm subst a)
   | .toField τ e a => .toField (Typ.instantiate subst τ) e (substInTypedTerm subst a)
   | .u8FromFieldUnsafe τ e a =>
     .u8FromFieldUnsafe (Typ.instantiate subst τ) e (substInTypedTerm subst a)
diff --git a/Ix/Aiur/Compiler/Layout.lean b/Ix/Aiur/Compiler/Layout.lean
index a43f1469..d18b5e68 100644
--- a/Ix/Aiur/Compiler/Layout.lean
+++ b/Ix/Aiur/Compiler/Layout.lean
@@ -224,6 +224,8 @@ def opLayout : Bytecode.Op → LayoutM Unit
   -- no lookup — same shape as `IORead`. The caller pins the values.
   | .unconstrainedGToBytes _ => do pushDegrees $ .replicate 8 1; bumpAuxiliaries 8
   | .unconstrainedGInverse _ => do pushDegree 1; bumpAuxiliaries
+  | .unconstrainedGlDivMod _ => do pushDegrees #[1, 1]; bumpAuxiliaries 2
+  | .unconstrainedGlInverse _ => do pushDegree 1; bumpAuxiliaries
   | .debug .. => pure ()
 
 /-- Termination helper for blockLayout's Block/Ctrl traversal. -/
diff --git a/Ix/Aiur/Compiler/Lower.lean b/Ix/Aiur/Compiler/Lower.lean
index 2ae268bb..8df8a951 100644
--- a/Ix/Aiur/Compiler/Lower.lean
+++ b/Ix/Aiur/Compiler/Lower.lean
@@ -151,7 +151,7 @@ def toIndex
   | .var _ _ name => pure (bindings[name]?.getD #[])
   | .ref _ _ name => match layoutMap[name]? with
     | some (.function layout) => do
-      pushOp (.const (.ofNat layout.index))
+      pushOp (.const layout.index)
     | some (.constructor layout) => do
       let size := layout.size
       -- Tagless single-variant: no tag slot. A nullary ctor is then a width-0
@@ -159,10 +159,10 @@ def toIndex
       if layout.tagless then
         if size == 0 then pure #[]
         else
-          let padding := (← pushOp (.const (.ofNat 0)))[0]!
+          let padding := (← pushOp (.const 0))[0]!
           pure $ Array.replicate size padding
       else
-        let paddingOp := Bytecode.Op.const (.ofNat layout.index)
+        let paddingOp := Bytecode.Op.const layout.index
         let index ← pushOp paddingOp
         if index.size < size then
           let padding := (← pushOp paddingOp)[0]!
@@ -202,10 +202,10 @@ def toIndex
       -- offset 0, exactly like a tuple.
       let index ←
         if layout.tagless then pure #[]
-        else pushOp (.const (.ofNat layout.index))
+        else pushOp (.const layout.index)
       let index ← buildArgs layoutMap bindings args index
       if index.size < size then
-        let padding := (← pushOp (.const (.ofNat 0)))[0]!
+        let padding := (← pushOp (.const 0))[0]!
         pure $ index ++ Array.replicate (size - index.size) padding
       else
         pure index
@@ -351,6 +351,12 @@ def toIndex
   | .unconstrainedGInverse _ _ a => do
     let a ← expectIdx layoutMap bindings a
     pushOp (.unconstrainedGInverse a)
+  | .unconstrainedGlDivMod _ _ a => do
+    let a ← expectIdx layoutMap bindings a
+    pushOp (.unconstrainedGlDivMod a) 2
+  | .unconstrainedGlInverse _ _ a => do
+    let a ← expectIdx layoutMap bindings a
+    pushOp (.unconstrainedGlInverse a)
   | .debug _ _ label term ret => do
     let term ← match term with
       | none => pure none
@@ -390,7 +396,7 @@ end
 /-- Compute the max aux/lookup usage across match-continue branches (for layout
 pre-reservation). Uses `Bytecode.blockLayout` with the current degree array. -/
 def Concrete.computeSharedLayout
-    (matchCases : Array (G × Bytecode.Block))
+    (matchCases : Array (Nat × Bytecode.Block))
     (defaultBlock : Option Bytecode.Block) : CompileM (Nat × Nat) := do
   let degrees := (← get).degrees
   let initLS : Bytecode.LayoutMState :=
@@ -549,9 +555,9 @@ def Concrete.addCase
     (returnTyp : Concrete.Typ)
     (idxs : Array Bytecode.ValIdx)
     (yieldCtrl : Bool := false) :
-    (Array (G × Bytecode.Block) × Option Bytecode.Block) →
+    (Array (Nat × Bytecode.Block) × Option Bytecode.Block) →
     (Concrete.Pattern × Concrete.Term) →
-    CompileM (Array (G × Bytecode.Block) × Option Bytecode.Block) :=
+    CompileM (Array (Nat × Bytecode.Block) × Option Bytecode.Block) :=
   fun (cases, defaultBlock) (pat, term) =>
     match pat with
     | .field g => do
@@ -583,7 +589,7 @@ def Concrete.addCase
       -- cases the `.match`/`.matchContinue` always falls through to it, so no tag
       -- discrimination occurs (`idxs[0]` is a field, never a tag).
       if tagless then pure (cases, .some term)
-      else pure (cases.push (.ofNat index, term), defaultBlock)
+      else pure (cases.push (index, term), defaultBlock)
     | .wildcard => do
       let initState ← get
       let term ← term.compile returnTyp layoutMap bindings yieldCtrl
diff --git a/Ix/Aiur/Compiler/Match.lean b/Ix/Aiur/Compiler/Match.lean
index 548468d1..29b31025 100644
--- a/Ix/Aiur/Compiler/Match.lean
+++ b/Ix/Aiur/Compiler/Match.lean
@@ -38,7 +38,7 @@ abbrev UniqTerm := TermId × Term
 /-- The patterns that `Simple.Pattern` admits directly, plus a `pointer` form
 that the match compiler lowers to a `letLoad`. -/
 inductive SPattern
-  | field : G → SPattern
+  | field : Nat → SPattern
   | ref : Global → Array Local → SPattern
   | tuple : Array Local → SPattern
   | array : Array Local → SPattern
@@ -397,6 +397,8 @@ def typedToSimple : Term → Simple.Term
   | .unconstrainedBigUintDivMod τ e a b => .unconstrainedBigUintDivMod τ e (typedToSimple a) (typedToSimple b)
   | .unconstrainedGToBytes τ e a => .unconstrainedGToBytes τ e (typedToSimple a)
   | .unconstrainedGInverse τ e a => .unconstrainedGInverse τ e (typedToSimple a)
+  | .unconstrainedGlDivMod τ e a => .unconstrainedGlDivMod τ e (typedToSimple a)
+  | .unconstrainedGlInverse τ e a => .unconstrainedGlInverse τ e (typedToSimple a)
   | .toField τ e a => .toField τ e (typedToSimple a)
   | .u8FromFieldUnsafe τ e a => .u8FromFieldUnsafe τ e (typedToSimple a)
   | .debug τ e l t r =>
diff --git a/Ix/Aiur/Compiler/Simple.lean b/Ix/Aiur/Compiler/Simple.lean
index 7f90bd6a..16395929 100644
--- a/Ix/Aiur/Compiler/Simple.lean
+++ b/Ix/Aiur/Compiler/Simple.lean
@@ -151,6 +151,12 @@ def simplifyTypedTerm (decls : Source.Decls) : Term → Except CheckError Term
   | .unconstrainedGInverse τ e a => do
       let a' ← simplifyTypedTerm decls a
       pure (.unconstrainedGInverse τ e a')
+  | .unconstrainedGlDivMod τ e a => do
+      let a' ← simplifyTypedTerm decls a
+      pure (.unconstrainedGlDivMod τ e a')
+  | .unconstrainedGlInverse τ e a => do
+      let a' ← simplifyTypedTerm decls a
+      pure (.unconstrainedGlInverse τ e a')
   | .toField τ e a => do
       let a' ← simplifyTypedTerm decls a
       pure (.toField τ e a')
diff --git a/Ix/Aiur/Goldilocks.lean b/Ix/Aiur/Goldilocks.lean
index b9745f73..431d0f9f 100644
--- a/Ix/Aiur/Goldilocks.lean
+++ b/Ix/Aiur/Goldilocks.lean
@@ -9,6 +9,16 @@ abbrev G := { u : UInt64 // u < gSize }
 
 abbrev G.extensionDegree : Nat := 2
 
+/-- Checked embedding: `none` iff the constant does not fit the field
+(constants are exact naturals; overflow means the field is not good for
+the circuit and must be an error at the consumer, never a wrap). -/
+def G.ofNat? (n : Nat) : Option G :=
+  if h : n < gSize.toNat then
+    some ⟨n.toUInt64, by
+      have : n.toUInt64.toNat = n := Nat.mod_eq_of_lt (Nat.lt_trans h (by decide))
+      simp [UInt64.lt_iff_toNat_lt, this, h]⟩
+  else none
+
 def G.ofNat (n : Nat) : G :=
   -- Reduce in `Nat` BEFORE narrowing: `toUInt64` wraps mod 2^64, which is
   -- NOT reduction mod p — narrowing first silently corrupts any value
diff --git a/Ix/Aiur/Interpret.lean b/Ix/Aiur/Interpret.lean
index efac94a8..3fc73c8f 100644
--- a/Ix/Aiur/Interpret.lean
+++ b/Ix/Aiur/Interpret.lean
@@ -84,7 +84,8 @@ private def matchPattern (store : Store) :
     Pattern → Value → Option Bindings
   | .wildcard,    _           => some []
   | .var l,       v           => some [(l, v)]
-  | .field g,     .field g'   => if g == g' then some [] else none
+  -- Checked embedding: an unrepresentable constant matches no value.
+  | .field g,     .field g'   => if G.ofNat? g == some g' then some [] else none
   | .tuple pats,  .tuple vs   => matchPatsArr store pats vs
   | .array pats,  .array vs   => matchPatsArr store pats vs
   | .ref g pats,  .ctor g' vs =>
@@ -302,7 +303,9 @@ partial def interp (decls : Decls) (bindings : Bindings) : Term → InterpM Valu
           else throwErr s!"ref: constructor '{g}' requires {ctor.argTypes.length} argument(s)"
       | some (.dataType _)          => throwErr s!"ref: '{g}' is a type, not a value"
       | none                        => throwErr s!"ref: '{g}' is not known"
-  | .field g  => return .field g
+  | .field g  => match G.ofNat? g with
+    | some gv => return .field gv
+    | none => throwErr s!"constant {g} does not fit the field"
   | .tuple ts => return .tuple (← ts.mapM (interp decls bindings))
   | .array ts => return .array (← ts.mapM (interp decls bindings))
   | .ret t   => do let v ← interp decls bindings t; throw (.ret v)
@@ -519,6 +522,14 @@ partial def interp (decls : Decls) (bindings : Bindings) : Term → InterpM Valu
       match ← interp decls bindings t with
       | .field g => return .field g.inverse
       | _ => throwErr "unconstrainedGInverse: expected field value"
+  | .unconstrainedGlDivMod t => do
+      match ← interp decls bindings t with
+      | .field g => return .tuple #[.field 0, .field g]
+      | _ => throwErr "unconstrainedGlDivMod: expected field value"
+  | .unconstrainedGlInverse t => do
+      match ← interp decls bindings t with
+      | .field g => return .field g.inverse
+      | _ => throwErr "unconstrainedGlInverse: expected field value"
   -- `toField` / `u8FromFieldUnsafe` are erased coercions: value unchanged.
   | .toField t | .u8FromFieldUnsafe t => interp decls bindings t
   | .u8Lit n => return .field (G.ofNat n)
diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean
index 5f8c13d3..220e3d12 100644
--- a/Ix/Aiur/Meta.lean
+++ b/Ix/Aiur/Meta.lean
@@ -69,7 +69,9 @@ def elabEmptyList (listEltTypeName : Name) : TermElabM Expr :=
   mkListLit (mkConst listEltTypeName) []
 
 def elabG (n : TSyntax `num) : TermElabM Expr :=
-  mkAppM ``G.ofNat #[mkNatLit n.getNat]
+  -- Constants are exact naturals; specialization to a field (with an
+  -- overflow ERROR, never a wrap) happens per consumer.
+  pure $ mkNatLit n.getNat
 
 partial def elabTyp : ElabStxCat `aiur_typ
   | `(aiur_typ| G) => pure $ mkConst ``Typ.field
@@ -210,6 +212,8 @@ syntax "u8_range_check" "(" aiur_trm ", " aiur_trm ")"                      : ai
 syntax "unconstrained_big_uint_div_mod" "(" aiur_trm ", " aiur_trm ")"           : aiur_trm
 syntax "unconstrained_g_to_bytes" "(" aiur_trm ")"                          : aiur_trm
 syntax "unconstrained_g_inverse" "(" aiur_trm ")"                           : aiur_trm
+syntax "unconstrained_gl_divmod" "(" aiur_trm ")"                           : aiur_trm
+syntax "unconstrained_gl_inverse" "(" aiur_trm ")"                          : aiur_trm
 syntax "to_field" "(" aiur_trm ")"                                          : aiur_trm
 syntax "u8_from_field_unsafe" "(" aiur_trm ")"                              : aiur_trm
 syntax:max num "u8"                                                         : aiur_trm
@@ -369,6 +373,10 @@ partial def elabTrm : ElabStxCat `aiur_trm
     mkAppM ``Source.Term.unconstrainedGToBytes #[← elabTrm a]
   | `(aiur_trm| unconstrained_g_inverse($a:aiur_trm)) => do
     mkAppM ``Source.Term.unconstrainedGInverse #[← elabTrm a]
+  | `(aiur_trm| unconstrained_gl_divmod($a:aiur_trm)) => do
+    mkAppM ``Source.Term.unconstrainedGlDivMod #[← elabTrm a]
+  | `(aiur_trm| unconstrained_gl_inverse($a:aiur_trm)) => do
+    mkAppM ``Source.Term.unconstrainedGlInverse #[← elabTrm a]
   | `(aiur_trm| to_field($a:aiur_trm)) => do
     mkAppM ``Source.Term.toField #[← elabTrm a]
   | `(aiur_trm| u8_from_field_unsafe($a:aiur_trm)) => do
@@ -615,6 +623,12 @@ where
     | `(aiur_trm| unconstrained_g_inverse($a:aiur_trm)) => do
       let a ← replaceToken old new a
       `(aiur_trm| unconstrained_g_inverse($a))
+    | `(aiur_trm| unconstrained_gl_divmod($a:aiur_trm)) => do
+      let a ← replaceToken old new a
+      `(aiur_trm| unconstrained_gl_divmod($a))
+    | `(aiur_trm| unconstrained_gl_inverse($a:aiur_trm)) => do
+      let a ← replaceToken old new a
+      `(aiur_trm| unconstrained_gl_inverse($a))
     | `(aiur_trm| to_field($a:aiur_trm)) => do
       let a ← replaceToken old new a
       `(aiur_trm| to_field($a))
diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean
index e5480b94..56cd1d3d 100644
--- a/Ix/Aiur/Protocol.lean
+++ b/Ix/Aiur/Protocol.lean
@@ -191,6 +191,42 @@ opaque verify : @& AiurSystem →
 
 end AiurSystem
 
+/-! ## Stage 3: the KZG (BLS12-381) instantiation
+
+The foreign (byte-limb) verifier toplevel specialized to the BLS12-381
+scalar field and proven under multi-stark's KZG backend — the terminal
+wrap. Execution inside the prove is the generic Aiur interpreter over
+the scalar field (no codegen'd Fr runner yet), and the proof travels as
+bytes (constant-size; `verify` is the native two-pairing check). -/
+
+private opaque AiurKzgSystemNonempty : NonemptyType
+def AiurKzgSystem : Type := AiurKzgSystemNonempty.type
+instance : Nonempty AiurKzgSystem := AiurKzgSystemNonempty.property
+
+namespace AiurKzgSystem
+
+/-- Build over the scalar field with DEV-GRADE public parameters
+(`Srs::unsafe_dev_setup`, size `2^logSrsSize`) — a placeholder until a
+ceremony loader lands. Constants specialize by exact embedding
+(everything shipped today is `< 2^64`). -/
+@[extern "rs_aiur_kzg_system_build"]
+opaque build : @& Bytecode.Toplevel → (logSrsSize : @& Nat) →
+  (maxQuotientDegree : @& Nat) → AiurKzgSystem
+
+/-- Prove the foreign verifier over raw proof/vk/claims byte blobs
+(advice layout as in `AiurSystem.proveMultiStark`). Returns the claim
+(values are exact `< 2^64` extractions) and the serialized KZG proof. -/
+@[extern "rs_aiur_kzg_multi_stark_prove"]
+opaque proveMultiStark : @& AiurKzgSystem →
+  (funIdx : @& Bytecode.FunIdx) → (pubInput : @& Array G) →
+  (proofBytes vkBytes claimBytes : @& ByteArray) → Array G × ByteArray
+
+@[extern "rs_aiur_kzg_system_verify"]
+opaque verify : @& AiurKzgSystem →
+  @& Array G → @& ByteArray → Except String Unit
+
+end AiurKzgSystem
+
 /-- One-shot variant of `AiurSystem.circuitShapes` for flows that never
 build an `AiurSystem` (the `ix check` statistics): Rust builds the system,
 extracts the shapes, and drops it. -/
diff --git a/Ix/Aiur/Semantics/BytecodeEval.lean b/Ix/Aiur/Semantics/BytecodeEval.lean
index 7656bcec..003e1d90 100644
--- a/Ix/Aiur/Semantics/BytecodeEval.lean
+++ b/Ix/Aiur/Semantics/BytecodeEval.lean
@@ -64,6 +64,9 @@ inductive BytecodeError
   | callOutputSizeMismatch
   | unreachableAfterLayout
   | u8RangeCheckFailed
+  /-- A constant does not fit the field: the field cannot represent the
+  circuit. -/
+  | constantOverflow (c : Nat)
   | unconstrainedBigUintDivModFailed
   | earlyReturn (outs : Array G) (st : EvalState)
   deriving Repr, Inhabited
@@ -170,7 +173,7 @@ private theorem Block.sizeOf_ctrl_lt (b : Block) : sizeOf b.ctrl < sizeOf b := b
 /-- For a match-case `(g, block)` drawn from `cases`, the block's `sizeOf` is
 strictly less than `sizeOf cases + sizeOf defaultBlock`. -/
 private theorem sizeOf_caseBlock_lt
-    (cases : Array (G × Block)) (defaultBlock : Option Block) (i : Nat)
+    (cases : Array (Nat × Block)) (defaultBlock : Option Block) (i : Nat)
     (h : i < cases.size) :
     sizeOf cases[i].snd < sizeOf cases + sizeOf defaultBlock := by
   have h1 : sizeOf cases[i] < sizeOf cases := Array.sizeOf_get cases i h
@@ -202,7 +205,9 @@ consumes fuel. -/
 def evalOp (t : Bytecode.Toplevel) (fuel : Nat) (op : Op) (st : EvalState) :
     Except BytecodeError EvalState :=
   match op with
-  | .const g => .ok (pushMap st g)
+  | .const g => match G.ofNat? g with
+    | some gv => .ok (pushMap st gv)
+    | none => .error (.constantOverflow g)
   | .add a b => do
     let x ← readIdx st a
     let y ← readIdx st b
@@ -376,6 +381,14 @@ def evalOp (t : Bytecode.Toplevel) (fuel : Nat) (op : Op) (st : EvalState) :
   | .unconstrainedGInverse idx => do
     let g ← readIdx st idx
     pure (pushMap st g.inverse)
+  -- Over Goldilocks every value is already < p: the quotient is 0 and the
+  -- inverse mod p IS the field inverse.
+  | .unconstrainedGlDivMod idx => do
+    let g ← readIdx st idx
+    pure (appendMap st #[0, g])
+  | .unconstrainedGlInverse idx => do
+    let g ← readIdx st idx
+    pure (pushMap st g.inverse)
   | .debug _ _ => .ok st
 termination_by (fuel, sizeOf op, 0)
 decreasing_by all_goals first | decreasing_tactic | omega
@@ -448,11 +461,12 @@ separate helper so each recursive step is structurally smaller than `cases`,
 which lets `Array.sizeOf_get` discharge the termination goal when we call
 `evalBlock` on an arm's `Block`. -/
 def evalMatchArm (t : Bytecode.Toplevel) (fuel : Nat)
-    (cases : Array (G × Block)) (defaultBlock : Option Block)
+    (cases : Array (Nat × Block)) (defaultBlock : Option Block)
     (scrut : G) (st : EvalState) (i : Nat := 0) :
     Except BytecodeError (Array G × EvalState) :=
   if h : i < cases.size then
-    if cases[i].fst == scrut then evalBlock t fuel cases[i].snd st
+    -- On-the-fly checked embedding: an unrepresentable key matches no value.
+    if G.ofNat? cases[i].fst == some scrut then evalBlock t fuel cases[i].snd st
     else evalMatchArm t fuel cases defaultBlock scrut st (i + 1)
   else evalDefaultBlock t fuel defaultBlock st
 termination_by (fuel, sizeOf cases + sizeOf defaultBlock, 2 + (cases.size - i))
diff --git a/Ix/Aiur/Semantics/SourceEval.lean b/Ix/Aiur/Semantics/SourceEval.lean
index c0ce18fc..f2d21cf7 100644
--- a/Ix/Aiur/Semantics/SourceEval.lean
+++ b/Ix/Aiur/Semantics/SourceEval.lean
@@ -69,6 +69,9 @@ inductive SourceError
   | ioReadOoB
   | invalidPointer (n : Nat)
   | notCallable (g : Global)
+  /-- A constant does not fit the field: the field cannot represent the
+  circuit. -/
+  | constantOverflow (c : Nat)
   | notAFunctionValue
   | earlyReturn (v : Value) (st : EvalState)
   deriving Repr, Inhabited
@@ -84,7 +87,8 @@ def matchPattern (store : Store) :
     Pattern → Value → Option Bindings
   | .wildcard,    _           => some []
   | .var l,       v           => some [(l, v)]
-  | .field g,     .field g'   => if g == g' then some [] else none
+  -- Checked embedding: an unrepresentable constant matches no value.
+  | .field g,     .field g'   => if G.ofNat? g == some g' then some [] else none
   | .tuple pats,  .tuple vs   => matchPatsArr store pats vs
   | .array pats,  .array vs   => matchPatsArr store pats vs
   | .ref g pats,  .ctor g' vs =>
@@ -318,7 +322,9 @@ def interp (decls : Decls) (fuel : Nat) (bindings : Bindings)
           else .error (.notCallable g)
       | some (.dataType _)          => .error (.notCallable g)
       | none                        => .error (.unboundGlobal g)
-  | .field g  => .ok (.field g, st)
+  | .field g  => match G.ofNat? g with
+    | some gv => .ok (.field gv, st)
+    | none => .error (.constantOverflow g)
   | .tuple ts =>
       match evalList decls fuel bindings ts.toList st with
       | .error e => .error e
@@ -616,6 +622,20 @@ def interp (decls : Decls) (fuel : Nat) (bindings : Bindings)
         match v with
         | .field g => .ok (.field g.inverse, st')
         | _ => .error (.typeMismatch "unconstrainedGInverse")
+  | .unconstrainedGlDivMod t =>
+      match interp decls fuel bindings t st with
+      | .error e => .error e
+      | .ok (v, st') =>
+        match v with
+        | .field g => .ok (.tuple #[.field 0, .field g], st')
+        | _ => .error (.typeMismatch "unconstrainedGlDivMod")
+  | .unconstrainedGlInverse t =>
+      match interp decls fuel bindings t st with
+      | .error e => .error e
+      | .ok (v, st') =>
+        match v with
+        | .field g => .ok (.field g.inverse, st')
+        | _ => .error (.typeMismatch "unconstrainedGlInverse")
   -- `toField` / `u8FromFieldUnsafe` are erased coercions: value unchanged.
   | .toField t | .u8FromFieldUnsafe t => interp decls fuel bindings t st
   | .u8Lit n => .ok (.field (G.ofNat n), st)
diff --git a/Ix/Aiur/Stages/Bytecode.lean b/Ix/Aiur/Stages/Bytecode.lean
index acd8e257..965fced6 100644
--- a/Ix/Aiur/Stages/Bytecode.lean
+++ b/Ix/Aiur/Stages/Bytecode.lean
@@ -19,7 +19,7 @@ abbrev ValIdx := Nat
 abbrev SelIdx := Nat
 
 inductive Op
-  | const : G → Op
+  | const : Nat → Op
   | add : ValIdx → ValIdx → Op
   | sub : ValIdx → ValIdx → Op
   | mul : ValIdx → ValIdx → Op
@@ -72,14 +72,23 @@ inductive Op
   | unconstrainedU32Add3 : Array ValIdx → Array ValIdx → Array ValIdx → Op
   /-- Virtual LE-byte packing expression; allocates no auxiliary column. -/
   | u32ToField : Array ValIdx → Op
+  /-- Unconstrained hint: `(q, r)` with `v = q·p_goldilocks + r`, `r < p`, over
+  the canonical integer of the outer-field value `v` (Goldilocks: `(0, v)`).
+  Two fresh auxiliary values, no relation; the caller pins them. Appended
+  last (tag 34). -/
+  | unconstrainedGlDivMod : ValIdx → Op
+  /-- Unconstrained hint: the inverse MODULO p_goldilocks of a canonical
+  value `< p` (`0 ↦ 0`). One fresh auxiliary value, no relation. Appended
+  last (tag 35). -/
+  | unconstrainedGlInverse : ValIdx → Op
   deriving Repr, BEq, Hashable
 
 mutual
   inductive Ctrl where
-    | match : ValIdx → Array (G × Block) → Option Block → Ctrl
+    | match : ValIdx → Array (Nat × Block) → Option Block → Ctrl
     | return : SelIdx → Array ValIdx → Ctrl
     | yield : SelIdx → Array ValIdx → Ctrl
-    | matchContinue : ValIdx → Array (G × Block) → Option Block
+    | matchContinue : ValIdx → Array (Nat × Block) → Option Block
         → (outputSize : Nat) → (sharedAuxiliaries : Nat) → (sharedLookups : Nat)
         → Block → Ctrl
     deriving Inhabited, Repr
@@ -115,6 +124,27 @@ def FunctionLayout.totalWidth (l : FunctionLayout) : Nat :=
     else max l.lookups 1
   l.width + G.extensionDegree * slots
 
+mutual
+  /-- Largest constant in a block (0 if none): `Op.const` values and match
+  keys. Consumers specialize constants to a concrete field and must ERROR
+  when this exceeds the field size (`maxConstant ≥ p` means the field
+  cannot represent the circuit). -/
+  partial def Block.maxConstant (b : Block) : Nat :=
+    b.ops.foldl (fun acc op => match op with
+      | .const c => max acc c
+      | _ => acc) (Ctrl.maxConstant b.ctrl)
+
+  partial def Ctrl.maxConstant : Ctrl → Nat
+    | .match _ cases def? =>
+      let m := cases.foldl (fun acc (c, b) => max acc (max c b.maxConstant)) 0
+      match def? with | some b => max m b.maxConstant | none => m
+    | .matchContinue _ cases def? _ _ _ cont =>
+      let m := cases.foldl (fun acc (c, b) => max acc (max c b.maxConstant)) 0
+      let m := match def? with | some b => max m b.maxConstant | none => m
+      max m cont.maxConstant
+    | .return _ _ | .yield _ _ => 0
+end
+
 structure Function where
   body : Block
   layout: FunctionLayout
@@ -127,6 +157,17 @@ structure Toplevel where
   memorySizes : Array Nat
   deriving Repr
 
+/-- Specialization guard: every constant must fit the target field. Run
+by each consumer (interpreter entry, FFI, codegen) before converting
+constants; overflow is an ERROR — the field cannot represent the
+circuit — never a silent wrap. -/
+def Toplevel.checkConstants (t : Toplevel) (fieldSize : Nat) :
+    Except String Unit := do
+  for f in t.functions do
+    let m := f.body.maxConstant
+    if m ≥ fieldSize then
+      throw s!"constant {m} does not fit the field (size {fieldSize}): the field cannot represent this circuit"
+
 end Bytecode
 
 end Aiur
diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean
index 3bf36a95..84c02483 100644
--- a/Ix/Aiur/Stages/Codegen.lean
+++ b/Ix/Aiur/Stages/Codegen.lean
@@ -354,12 +354,14 @@ def Op.outputCount : Op → Nat
   | .unconstrainedBigUintDivMod _ _ => 2
   | .unconstrainedGToBytes _ => 8
   | .unconstrainedGInverse _ => 1
+  | .unconstrainedGlDivMod _ => 2
+  | .unconstrainedGlInverse _ => 1
   | .unconstrainedU32Add _ _ | .unconstrainedU32Add3 _ _ _ => 5
   | .u32ToField _ => 1
   | .debug _ _ => 0
 
-private def emitConst (out : Nat) (c : Aiur.G) : Array RustStmt :=
-  #[declVal out (gFromU64 c.n)]
+private def emitConst (out : Nat) (c : Nat) : Array RustStmt :=
+  #[declVal out (gFromU64 c)]
 
 private def emitBinop (out : Nat) (op : String) (a b : ValIdx) : Array RustStmt :=
   #[declVal out (.binop op (valVar a) (valVar b))]
@@ -683,6 +685,17 @@ private def emitUncGToBytes (out : Nat) (a : ValIdx) : Array RustStmt := Id.run
 private def emitUncGInverse (out : Nat) (a : ValIdx) : Array RustStmt :=
   #[declVal out (.lit s!"g_inverse_value(__v_{a})")]
 
+/-- `Op::UnconstrainedGlDivMod`: 2 outputs `(q, r)` — the canonical value
+    split as `q·p_goldilocks + r`, via the shared `gl_divmod_value` helper. -/
+private def emitUncGlDivMod (out : Nat) (a : ValIdx) : Array RustStmt :=
+  #[.letStmt false "__gl_dm" none (.lit s!"gl_divmod_value(__v_{a})"),
+    declVal out (.lit "__gl_dm.0"), declVal (out + 1) (.lit "__gl_dm.1")]
+
+/-- `Op::UnconstrainedGlInverse`: 1 output — the inverse modulo p_goldilocks
+    (`0 ↦ 0`), via the shared `gl_inverse_value` helper. -/
+private def emitUncGlInverse (out : Nat) (a : ValIdx) : Array RustStmt :=
+  #[declVal out (.lit s!"gl_inverse_value(__v_{a})")]
+
 /-- `Op::Debug`: 0 outputs; println side effect, mirroring the bytecode
     interpreter's `Op::Debug` arm (crates/aiur/src/execute.rs). Production
     kernels contain no `dbg!`, so this emits nothing there; when probing
@@ -733,6 +746,8 @@ def emitOp (out : Nat) (op : Op) : Array RustStmt :=
   | .unconstrainedBigUintDivMod a b => emitUncBigUintDivMod out a b
   | .unconstrainedGToBytes a => emitUncGToBytes out a
   | .unconstrainedGInverse a => emitUncGInverse out a
+  | .unconstrainedGlDivMod a => emitUncGlDivMod out a
+  | .unconstrainedGlInverse a => emitUncGlInverse out a
   | .unconstrainedU32Add a b => emitUnconstrainedU32Add out [a, b]
   | .unconstrainedU32Add3 a b c => emitUnconstrainedU32Add out [a, b, c]
   | .u32ToField a => emitU32ToField out a
@@ -834,7 +849,7 @@ partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String)
     let mut arms : Array MatchArm := #[]
     for ⟨key, blk⟩ in cases do
       let armBody ← withSavedNextVal (emitBlock funIdx mcLabel? blk)
-      arms := arms.push { pat := .litU64 key.n, body := armBody }
+      arms := arms.push { pat := .litU64 key, body := armBody }
     let dfltBody ← (match dflt? with
       | some d => withSavedNextVal (emitBlock funIdx mcLabel? d)
       | none => pure #[
@@ -866,7 +881,7 @@ partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String)
     let mut arms : Array MatchArm := #[]
     for ⟨key, blk⟩ in cases do
       let armBody ← withSavedNextVal (emitBlock funIdx (some label) blk)
-      arms := arms.push { pat := .litU64 key.n, body := armBody }
+      arms := arms.push { pat := .litU64 key, body := armBody }
     let dfltBody ← (match dflt? with
       | some d => withSavedNextVal (emitBlock funIdx (some label) d)
       | none => pure #[
@@ -987,6 +1002,8 @@ def optionalExecuteUses : Array (String × String) := #[
   ("bytes2_xor_split4_value", "bytes2_xor_split4_value"),
   ("unconstrained_big_uint_div_mod_helper", "unconstrained_big_uint_div_mod_helper"),
   ("g_inverse_value", "g_inverse_value"),
+  ("gl_divmod_value", "gl_divmod_value"),
+  ("gl_inverse_value", "gl_inverse_value"),
   ("CodegenBytes1 as Bytes1", "Bytes1::"),
   ("CodegenBytes2 as Bytes2", "Bytes2::")
 ]
diff --git a/Ix/Aiur/Stages/Concrete.lean b/Ix/Aiur/Stages/Concrete.lean
index f563ecb5..c56ecded 100644
--- a/Ix/Aiur/Stages/Concrete.lean
+++ b/Ix/Aiur/Stages/Concrete.lean
@@ -30,7 +30,7 @@ inductive Typ where
 
 inductive Pattern
   | wildcard
-  | field : G → Pattern
+  | field : Nat → Pattern
   | ref : Global → Array Local → Pattern
   | tuple : Array Local → Pattern
   | array : Array Local → Pattern
@@ -46,7 +46,7 @@ inductive Term : Type where
   | unit (typ : Typ) (escapes : Bool) : Term
   | var (typ : Typ) (escapes : Bool) (l : Local) : Term
   | ref (typ : Typ) (escapes : Bool) (g : Global) : Term
-  | field (typ : Typ) (escapes : Bool) (g : G) : Term
+  | field (typ : Typ) (escapes : Bool) (g : Nat) : Term
   | tuple (typ : Typ) (escapes : Bool) (ts : Array Term) : Term
   | array (typ : Typ) (escapes : Bool) (ts : Array Term) : Term
   | ret (typ : Typ) (escapes : Bool) (sub : Term) : Term
@@ -94,6 +94,8 @@ inductive Term : Type where
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term
   | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGlDivMod (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGlInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
   | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term
   deriving Repr, Inhabited
 
@@ -115,6 +117,7 @@ def Term.typ : Term → Typ
   | .unconstrainedU32Add t _ _ _ | .unconstrainedU32Add3 t _ _ _ _ | .u32ToField t _ _
   | .unconstrainedBigUintDivMod t _ _ _
   | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _
+  | .unconstrainedGlDivMod t _ _ | .unconstrainedGlInverse t _ _
   | .debug t _ _ _ _ => t
 
 /-- Get the escapes flag of a Concrete.Term. -/
@@ -135,6 +138,7 @@ def Term.escapes : Term → Bool
   | .unconstrainedU32Add _ e _ _ | .unconstrainedU32Add3 _ e _ _ _ | .u32ToField _ e _
   | .unconstrainedBigUintDivMod _ e _ _
   | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _
+  | .unconstrainedGlDivMod _ e _ | .unconstrainedGlInverse _ e _
   | .debug _ e _ _ _ => e
 
 structure Constructor where
diff --git a/Ix/Aiur/Stages/Simple.lean b/Ix/Aiur/Stages/Simple.lean
index 4e35c18e..568b3eae 100644
--- a/Ix/Aiur/Stages/Simple.lean
+++ b/Ix/Aiur/Stages/Simple.lean
@@ -28,7 +28,7 @@ namespace Simple
 /-- Simplified pattern: bare-local children only. -/
 inductive Pattern
   | wildcard
-  | field : G → Pattern
+  | field : Nat → Pattern
   | ref : Global → Array Local → Pattern
   | tuple : Array Local → Pattern
   | array : Array Local → Pattern
@@ -41,7 +41,7 @@ inductive Term : Type where
   | unit (typ : Typ) (escapes : Bool) : Term
   | var (typ : Typ) (escapes : Bool) (l : Local) : Term
   | ref (typ : Typ) (escapes : Bool) (g : Global) (tArgs : Array Typ) : Term
-  | field (typ : Typ) (escapes : Bool) (g : G) : Term
+  | field (typ : Typ) (escapes : Bool) (g : Nat) : Term
   | tuple (typ : Typ) (escapes : Bool) (ts : Array Term) : Term
   | array (typ : Typ) (escapes : Bool) (ts : Array Term) : Term
   | ret (typ : Typ) (escapes : Bool) (sub : Term) : Term
@@ -90,6 +90,8 @@ inductive Term : Type where
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term
   | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGlDivMod (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGlInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
   | toField (typ : Typ) (escapes : Bool) (a : Term) : Term
   | u8FromFieldUnsafe (typ : Typ) (escapes : Bool) (a : Term) : Term
   | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term
@@ -112,6 +114,7 @@ def Term.typ : Term → Typ
   | .unconstrainedU32Add t _ _ _ | .unconstrainedU32Add3 t _ _ _ _ | .u32ToField t _ _
   | .unconstrainedBigUintDivMod t _ _ _
   | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _
+  | .unconstrainedGlDivMod t _ _ | .unconstrainedGlInverse t _ _
   | .toField t _ _ | .u8FromFieldUnsafe t _ _
   | .debug t _ _ _ _ => t
 
@@ -132,6 +135,7 @@ def Term.escapes : Term → Bool
   | .unconstrainedU32Add _ e _ _ | .unconstrainedU32Add3 _ e _ _ _ | .u32ToField _ e _
   | .unconstrainedBigUintDivMod _ e _ _
   | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _
+  | .unconstrainedGlDivMod _ e _ | .unconstrainedGlInverse _ e _
   | .toField _ e _ | .u8FromFieldUnsafe _ e _
   | .debug _ e _ _ _ => e
 
diff --git a/Ix/Aiur/Stages/Source.lean b/Ix/Aiur/Stages/Source.lean
index d4441383..cc6ad4c0 100644
--- a/Ix/Aiur/Stages/Source.lean
+++ b/Ix/Aiur/Stages/Source.lean
@@ -365,7 +365,7 @@ inductive Pattern
   | var : Local → Pattern
   | wildcard : Pattern
   | ref : Global → List Pattern → Pattern
-  | field : G → Pattern
+  | field : Nat → Pattern
   | tuple : Array Pattern → Pattern
   | array : Array Pattern → Pattern
   | or : Pattern → Pattern → Pattern
@@ -395,7 +395,7 @@ inductive Term
   | unit
   | var : Local → Term
   | ref : Global → Term
-  | field : G → Term
+  | field : Nat → Term
   | tuple : Array Term → Term
   | array : Array Term → Term
   | ret : Term → Term
@@ -460,6 +460,14 @@ inductive Term
   caller must pin it, e.g. via `t = x·i − 1; assert x·t == 0;
   assert i·t == 0` (forces `i = x⁻¹` when `x ≠ 0` and `i = 0` otherwise). -/
   | unconstrainedGInverse : Term → Term
+  /-- Unconstrained hint: `(q, r)` with `v = q·p_goldilocks + r`, `r < p`, over
+  the canonical integer of the outer-field value `v` (Goldilocks: `(0, v)`).
+  Two fresh field values, no constraint relation; the caller pins them. -/
+  | unconstrainedGlDivMod : Term → Term
+  /-- Unconstrained hint: the inverse of a canonical value `< p_goldilocks`
+  MODULO p_goldilocks (`0 ↦ 0`), as an outer-field value. One fresh field
+  value, no constraint relation; the caller pins it. -/
+  | unconstrainedGlInverse : Term → Term
   /-- A `U8` literal in `[0, 256)`. Lowered to a plain field constant of type
   `u8` (no range-check lookup, since the value is statically in range). -/
   | u8Lit : Nat → Term
@@ -703,6 +711,8 @@ def Term.freshen (cnt : Nat) (subst : Std.HashMap Local Local) :
   | .u8FromFieldUnsafe a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8FromFieldUnsafe a')
   | .unconstrainedGToBytes a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .unconstrainedGToBytes a')
   | .unconstrainedGInverse a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .unconstrainedGInverse a')
+  | .unconstrainedGlDivMod a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .unconstrainedGlDivMod a')
+  | .unconstrainedGlInverse a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .unconstrainedGlInverse a')
   | .debug s o a =>
     let (cnt, o') := match o with
       | none => (cnt, none)
@@ -754,7 +764,8 @@ def Term.inlineCallSites : Term → List (Global × Nat)
   | .ret a | .eqZero a | .proj a _ | .get a _ | .slice a _ _ | .store a | .load a
   | .ptrVal a | .ann _ a | .u8BitDecomposition a | .u8ShiftLeft a | .u8ShiftRight a
   | .toField a | .u8FromFieldUnsafe a
-  | .unconstrainedGToBytes a | .unconstrainedGInverse a => a.inlineCallSites
+  | .unconstrainedGToBytes a | .unconstrainedGInverse a
+  | .unconstrainedGlDivMod a | .unconstrainedGlInverse a => a.inlineCallSites
   | .u32ToField a => a.inlineCallSites
   | .unconstrainedU32Add3 a b c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites
   | .debug _ o a => (match o with | none => [] | some x => x.inlineCallSites) ++ a.inlineCallSites
@@ -877,6 +888,8 @@ def Term.expandOnce (done : Std.HashMap Global (List Local × Term)) (cnt : Nat)
   | .u8FromFieldUnsafe a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8FromFieldUnsafe a')
   | .unconstrainedGToBytes a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .unconstrainedGToBytes a')
   | .unconstrainedGInverse a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .unconstrainedGInverse a')
+  | .unconstrainedGlDivMod a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .unconstrainedGlDivMod a')
+  | .unconstrainedGlInverse a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .unconstrainedGlInverse a')
   | .debug s o a =>
     let (cnt, o') := match o with
       | none => (cnt, none)
@@ -976,6 +989,8 @@ def Term.hoistLets : Term → Term :=
   | .u8FromFieldUnsafe a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8FromFieldUnsafe c)
   | .unconstrainedGToBytes a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.unconstrainedGToBytes c)
   | .unconstrainedGInverse a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.unconstrainedGInverse c)
+  | .unconstrainedGlDivMod a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.unconstrainedGlDivMod c)
+  | .unconstrainedGlInverse a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.unconstrainedGlInverse c)
   | .u8Xor a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
                   match cs with | [a, b] => Term.wrapLets fs (.u8Xor a b) | _ => t
   | .u8Add a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
@@ -1089,6 +1104,7 @@ partial def Term.collectGlobals (acc : Std.HashSet Global) : Term → Std.HashSe
   | .ret t | .eqZero t | .proj t _ | .get t _ | .slice t _ _ | .store t
   | .load t | .ptrVal t | .ann _ t | .u8BitDecomposition t | .u8ShiftLeft t
   | .u8ShiftRight t | .unconstrainedGToBytes t | .unconstrainedGInverse t
+  | .unconstrainedGlDivMod t | .unconstrainedGlInverse t
   | .u32ToField t
   | .toField t | .u8FromFieldUnsafe t => t.collectGlobals acc
   | .let p v b => b.collectGlobals (v.collectGlobals (patternGlobals acc p))
diff --git a/Ix/Aiur/Stages/Typed.lean b/Ix/Aiur/Stages/Typed.lean
index 55bc14c4..73a6e209 100644
--- a/Ix/Aiur/Stages/Typed.lean
+++ b/Ix/Aiur/Stages/Typed.lean
@@ -21,7 +21,7 @@ inductive Term : Type where
   | unit (typ : Typ) (escapes : Bool) : Term
   | var (typ : Typ) (escapes : Bool) (l : Local) : Term
   | ref (typ : Typ) (escapes : Bool) (g : Global) (tArgs : Array Typ) : Term
-  | field (typ : Typ) (escapes : Bool) (g : G) : Term
+  | field (typ : Typ) (escapes : Bool) (g : Nat) : Term
   | tuple (typ : Typ) (escapes : Bool) (ts : Array Term) : Term
   | array (typ : Typ) (escapes : Bool) (ts : Array Term) : Term
   | ret (typ : Typ) (escapes : Bool) (sub : Term) : Term
@@ -66,6 +66,8 @@ inductive Term : Type where
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term
   | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGlDivMod (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGlInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
   | toField (typ : Typ) (escapes : Bool) (a : Term) : Term
   | u8FromFieldUnsafe (typ : Typ) (escapes : Bool) (a : Term) : Term
   | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term
@@ -88,6 +90,7 @@ def Term.typ : Term → Typ
   | .unconstrainedU32Add t _ _ _ | .unconstrainedU32Add3 t _ _ _ _ | .u32ToField t _ _
   | .unconstrainedBigUintDivMod t _ _ _
   | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _
+  | .unconstrainedGlDivMod t _ _ | .unconstrainedGlInverse t _ _
   | .toField t _ _ | .u8FromFieldUnsafe t _ _
   | .debug t _ _ _ _ => t
 
@@ -108,6 +111,7 @@ def Term.escapes : Term → Bool
   | .unconstrainedU32Add _ e _ _ | .unconstrainedU32Add3 _ e _ _ _ | .u32ToField _ e _
   | .unconstrainedBigUintDivMod _ e _ _
   | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _
+  | .unconstrainedGlDivMod _ e _ | .unconstrainedGlInverse _ e _
   | .toField _ e _ | .u8FromFieldUnsafe _ e _
   | .debug _ e _ _ _ => e
 
diff --git a/Ix/Cli/BenchCmd.lean b/Ix/Cli/BenchCmd.lean
index c68bd30d..65f1774e 100644
--- a/Ix/Cli/BenchCmd.lean
+++ b/Ix/Cli/BenchCmd.lean
@@ -252,8 +252,10 @@ def backendSpecs : List BackendSpec := [
   -- every stage of the pipeline, per constant, plus the total. Stage 1
   -- proves the constant's IxVM typecheck; stage 2 executes the
   -- in-circuit multi-stark verifier over the fresh stage-1 proof and
-  -- proves THAT execution; the KZG stages will join as stages 3/4 when
-  -- they land, folding into the same ledger. Each stage reports the same
+  -- proves THAT execution; stage 3 proves the FOREIGN (large-field
+  -- Goldilocks emulation) verifier's acceptance of the stage-2 proof over
+  -- the BLS12-381 scalar field under the KZG backend — the constant-
+  -- size, natively-verified wrap (dev-grade SRS). Each stage reports the same
   -- five columns — witness execute, prove, peak RAM, proof size, verify
   -- — and the closing ledger table carries `total-time` (the stages'
   -- proves, summed — each prove already runs its own witness execution,
@@ -277,6 +279,9 @@ def backendSpecs : List BackendSpec := [
          ["recursive-execute-time", "recursive-prove-time",
           "recursive-peak-rss", "recursive-proof-size",
           "recursive-verify-time", "recursive-fft-cost"]),
+       ("Stage 3 — FRI recursion on KZG (BLS12-381)",
+         ["kzg-prove-time", "kzg-peak-rss", "kzg-proof-size",
+          "kzg-verify-time"]),
        ("Pipeline total", ["total-time", "pipeline-peak-rss"])])],
     metrics := [("execute", ["execute-time", "throughput", "peak-rss",
                              "fft-cost"])],
@@ -300,7 +305,11 @@ def backendSpecs : List BackendSpec := [
                    ("proof-size", "0.05", "_"),
                    ("recursive-proof-size", "0.05", "_"),
                    ("verify-time", "0.10", "_"),
-                   ("recursive-verify-time", "0.10", "_")] },
+                   ("recursive-verify-time", "0.10", "_"),
+                   ("kzg-prove-time", "0.10", "_"),
+                   ("kzg-peak-rss", "0.10", "_"),
+                   ("kzg-proof-size", "0.05", "_"),
+                   ("kzg-verify-time", "0.10", "_")] },
   { name := "zisk", defaultMode := "execute", inputs := .perConstant,
     testbeds := [("execute", "zisk-check-execute-x64-32x")],
     metrics := [("execute", ["execute-time", "throughput", "peak-rss",
@@ -794,7 +803,7 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do
       if exit != 0 && exit != exitRejected then
         IO.eprintln s!"[bench] per-constant closures failed (exit {exit})"
   | "aiur" =>
-    -- prove runs the whole pipeline (`bench-typecheck --recursive`):
+    -- prove runs the whole pipeline (`bench-typecheck --recursive --kzg`):
     -- every stage per constant, closed by the pipeline ledger. One process
     -- per constant under the watchdog; `total-time` is the ledger's last
     -- field, so it doubles as the completion marker — a kill before the
@@ -803,7 +812,7 @@ def runBenchRunCmd (p : Cli.Parsed) : IO UInt32 := do
     let bt ← resolveBin repo "bench-typecheck"
     let (modeArgs, doneKey) := match mode with
       | "execute" => (#["--execute-only"], "execute-time")
-      | _ => (#["--recursive"], "total-time")
+      | _ => (#["--recursive", "--kzg"], "total-time")
     runPerConstant out names doneKey fun name =>
       runGuarded watchdog ceilingGb bt
         (#["--ixe", ixe, "--consts", name, "--json", out, "--texray"]
diff --git a/Ix/Cli/BenchPlots.lean b/Ix/Cli/BenchPlots.lean
index 29a9d2a9..39e7fc42 100644
--- a/Ix/Cli/BenchPlots.lean
+++ b/Ix/Cli/BenchPlots.lean
@@ -67,6 +67,10 @@ def plotTitle (workload measure : String) : String :=
   | "aiur", "recursive-verify-time"  => "Aiur Stage 2 Verify Time"
   | "aiur", "recursive-peak-rss"     => "Aiur Stage 2 Peak RAM Usage"
   | "aiur", "recursive-proof-size"   => "Aiur Stage 2 Proof Size"
+  | "aiur", "kzg-prove-time"         => "Aiur Stage 3 Time"
+  | "aiur", "kzg-verify-time"        => "Aiur Stage 3 Verify Time"
+  | "aiur", "kzg-peak-rss"           => "Aiur Stage 3 Peak RAM Usage"
+  | "aiur", "kzg-proof-size"         => "Aiur Stage 3 Proof Size"
   | "zisk-check-execute", "execute-time" => "Zisk Execute Time"
   | "zisk-check-execute", "throughput"   => "Zisk Execute Throughput"
   | "zisk-check-execute", "peak-rss"     => "Zisk Execute Peak RAM Usage"
@@ -128,6 +132,10 @@ def unitsFor (slug : String) : Option String :=
    ("recursive-proof-size", "bytes (B)"),
    ("recursive-fft-cost", "FFTs"),
    ("total-time", "seconds (s)"),
+   ("kzg-prove-time", "seconds (s)"),
+   ("kzg-verify-time", "seconds (s)"),
+   ("kzg-peak-rss", "bytes (B)"),
+   ("kzg-proof-size", "bytes (B)"),
    ("pipeline-peak-rss", "bytes (B)"),
    ("throughput", "constants / second")].lookup slug
 
diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean
index f958c4be..9efb22a3 100644
--- a/Ix/Cli/CodegenCmd.lean
+++ b/Ix/Cli/CodegenCmd.lean
@@ -66,6 +66,10 @@ def emitTarget (checkOnly : Bool) (t : Target) : IO Bool := do
   let compiled ← match src.compile with
     | .ok c => pure c
     | .error e => IO.eprintln s!"{t.label} Aiur compile error: {e}"; return false
+  -- Specialization guard: the emitted Rust bakes constants into the
+  -- Goldilocks field; a constant that does not fit is a hard error.
+  if let .error e := compiled.bytecode.checkConstants Aiur.gSize.toNat then
+    throw $ IO.userError s!"codegen: {e}"
   let rustSource := Aiur.Codegen.emit compiled.bytecode
   if checkOnly then
     -- CI mode: compare emitted source against the on-disk file.
diff --git a/Ix/IxVM/Kernel/CanonicalCheck.lean b/Ix/IxVM/Kernel/CanonicalCheck.lean
index e778d832..35371aef 100644
--- a/Ix/IxVM/Kernel/CanonicalCheck.lean
+++ b/Ix/IxVM/Kernel/CanonicalCheck.lean
@@ -1,7 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Ingress
 
 public section
 
diff --git a/Ix/IxVM/Kernel/Check.lean b/Ix/IxVM/Kernel/Check.lean
index 51723f33..3c34841b 100644
--- a/Ix/IxVM/Kernel/Check.lean
+++ b/Ix/IxVM/Kernel/Check.lean
@@ -1,9 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Levels
-public import Ix.IxVM.Kernel.Infer
-public import Ix.IxVM.Ingress
 
 public section
 
diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean
index a16176cf..f3043f75 100644
--- a/Ix/IxVM/Kernel/Claim.lean
+++ b/Ix/IxVM/Kernel/Claim.lean
@@ -1,8 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Check
-public import Ix.IxVM.Ingress
 
 public section
 
diff --git a/Ix/IxVM/Kernel/DefEq.lean b/Ix/IxVM/Kernel/DefEq.lean
index 15bbaa8c..396ef84c 100644
--- a/Ix/IxVM/Kernel/DefEq.lean
+++ b/Ix/IxVM/Kernel/DefEq.lean
@@ -1,13 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Subst
-public import Ix.IxVM.Kernel.Levels
-public import Ix.IxVM.Kernel.Klimbs
-public import Ix.IxVM.Kernel.NatPrim
-public import Ix.IxVM.Kernel.Whnf
-public import Ix.IxVM.Kernel.InferOnly
-public import Ix.IxVM.Ingress
 
 public section
 
diff --git a/Ix/IxVM/Kernel/Infer.lean b/Ix/IxVM/Kernel/Infer.lean
index 1a54e3ed..e51f02d5 100644
--- a/Ix/IxVM/Kernel/Infer.lean
+++ b/Ix/IxVM/Kernel/Infer.lean
@@ -1,11 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Subst
-public import Ix.IxVM.Kernel.Levels
-public import Ix.IxVM.Kernel.Whnf
-public import Ix.IxVM.Kernel.DefEq
-public import Ix.IxVM.Ingress
 
 public section
 
diff --git a/Ix/IxVM/Kernel/InferOnly.lean b/Ix/IxVM/Kernel/InferOnly.lean
index 3e850804..913998f3 100644
--- a/Ix/IxVM/Kernel/InferOnly.lean
+++ b/Ix/IxVM/Kernel/InferOnly.lean
@@ -1,10 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Subst
-public import Ix.IxVM.Kernel.Levels
-public import Ix.IxVM.Kernel.Whnf
-public import Ix.IxVM.Ingress
 
 public section
 
diff --git a/Ix/IxVM/Kernel/Levels.lean b/Ix/IxVM/Kernel/Levels.lean
index a01a780f..6c4044ce 100644
--- a/Ix/IxVM/Kernel/Levels.lean
+++ b/Ix/IxVM/Kernel/Levels.lean
@@ -1,6 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
 
 public section
 
diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean
index cabd6918..6125b8bc 100644
--- a/Ix/IxVM/Kernel/NatPrim.lean
+++ b/Ix/IxVM/Kernel/NatPrim.lean
@@ -1,7 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Klimbs
 
 set_option maxRecDepth 8192
 
diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean
index b55ca08f..600b0502 100644
--- a/Ix/IxVM/Kernel/Subst.lean
+++ b/Ix/IxVM/Kernel/Subst.lean
@@ -1,6 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
 
 public section
 
diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean
index aeebd513..0aa2ecf5 100644
--- a/Ix/IxVM/Kernel/Whnf.lean
+++ b/Ix/IxVM/Kernel/Whnf.lean
@@ -1,10 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Subst
-public import Ix.IxVM.Kernel.Levels
-public import Ix.IxVM.Kernel.NatPrim
-public import Ix.IxVM.Ingress
 
 public section
 
diff --git a/Ix/MultiStark.lean b/Ix/MultiStark.lean
index d093328b..3f6b840e 100644
--- a/Ix/MultiStark.lean
+++ b/Ix/MultiStark.lean
@@ -5,10 +5,13 @@ public import Ix.Aiur.Protocol
 public import Ix.IxVM.Core
 public import Ix.IxVM.ByteStream
 public import Ix.IxVM.Blake3
-public import Ix.MultiStark.Goldilocks
+public import Ix.MultiStark.Field.GoldilocksNative
+public import Ix.MultiStark.Field.GoldilocksForeign
+public import Ix.MultiStark.Transcript.Blake3
+public import Ix.MultiStark.Domain
 public import Ix.MultiStark.Deserialize
 public import Ix.MultiStark.Keccak
-public import Ix.MultiStark.Pcs
+public import Ix.MultiStark.Pcs.Fri
 public import Ix.MultiStark.SystemDeserialize
 public import Ix.MultiStark.Verifier
 public import Ix.MultiStark.Tests
@@ -86,14 +89,39 @@ def entrypoints := ⟦
   }
 ⟧
 
-/-- The FULL Multi-STARK verifier toplevel: `core` (lists/options) +
-`byteStream` (`U64`, `flatten_u64`, `read_byte_stream`, …) + the deserializer,
-the Blake3 hash, and the entrypoint — unpruned, including entries inherited
-from the shared modules (`blake3_test`/`blake3_bench`). Only `multiStarkTests`
-builds on this; production uses `multiStark` (pruned). -/
-def multiStarkFull : Except Aiur.Global Aiur.Source.Toplevel := do
+/-- The FULL Multi-STARK verifier toplevel, assembled from one implementation
+of each interface — the verifier core is written against interface NAMES,
+mirroring multi-stark's `pcs-traits` (generic over the field and the PCS):
+
+* **Field** (`Ix/MultiStark/Field/*`): types `Val` (the verified system's
+  base field, Rust `Val<SC>`) and `Ext` (its extension / challenge field);
+  values `val_zero/one/two/generator/two_adic_root`, `ext_w`; ops
+  `val_add/sub/neg/mul/is_zero/inverse`, `ext_add/sub/neg/mul/inverse/div/eq`;
+  wire boundary `val_from_bytes`/`val_to_bytes`/`val_from_u16`/
+  `bytes_lt_modulus`. Implementations: `goldilocksNative` (`Val = G`),
+  `goldilocksForeign` (Goldilocks emulated in a large outer field).
+* **Pcs** (`Ix/MultiStark/Pcs/*`): types `Commitment`, `PcsProof`,
+  `PcsParams`; readers `read_commitment_at`/`read_pcs_proof` (proof stream),
+  `read_vk_commitment`/`read_pcs_params` (vk stream); transcript bytes
+  `commitment_onto`/`snoc_commitment`; `pcs_empty_commitment`; and
+  `pcs_verify` (Rust `Pcs::verify`). Implementation: `pcsFri`.
+* **Transcript** (`Ix/MultiStark/Transcript/Blake3.lean`): the byte
+  challenger (`ch_*`) — blake3, the one implementation by design.
+* **Domain** (`Ix/MultiStark/Domain.lean`): two-adic coset math over the
+  field interface, shared by every PCS.
+
+Exactly one implementation of each interface merges (same names by design).
+The merge: `core` (lists/options) + `byteStream` + field + transcript +
+domain + the deserializer + Blake3 + the vk deserializer + PCS + the verifier
+core + the entrypoint — unpruned, including entries inherited from the
+shared modules. Only the `*Tests` toplevels build on this; production uses
+the pruned forms. -/
+def multiStarkFullOver (field pcs : Aiur.Source.Toplevel) :
+    Except Aiur.Global Aiur.Source.Toplevel := do
   let t ← IxVM.core.merge IxVM.byteStream
-  let t ← t.merge MultiStark.goldilocks
+  let t ← t.merge field
+  let t ← t.merge transcriptBlake3
+  let t ← t.merge twoAdicDomain
   let t ← t.merge deserialize
   let t ← t.merge IxVM.blake3
   let t ← t.merge systemDeserialize
@@ -101,6 +129,18 @@ def multiStarkFull : Except Aiur.Global Aiur.Source.Toplevel := do
   let t ← t.merge verifier
   t.merge entrypoints
 
+/-- The native instantiation: Goldilocks as `Val` itself, the FRI PCS. -/
+def multiStarkFull : Except Aiur.Global Aiur.Source.Toplevel :=
+  multiStarkFullOver MultiStark.goldilocksNative MultiStark.pcsFri
+
+/-- `multiStarkFull` with the byte-limb inner field: the SAME verifier
+program, its Goldilocks arithmetic emulated on bytes, so the toplevel is
+outer-field-independent — executable under the Goldilocks interpreter today
+(the Phase-B gate) and provable over the BLS12-381 scalar field under the
+KZG backend (stage 3). -/
+def multiStarkForeignFull : Except Aiur.Global Aiur.Source.Toplevel :=
+  multiStarkFullOver MultiStark.goldilocksForeign MultiStark.pcsFri
+
 /-- The production Multi-STARK verifier toplevel: `multiStarkFull` pruned to
 `verify_multi_stark_proof`'s call closure. Every compiled function is a
 committed circuit whose openings pad every proof of the verifier's execution,
@@ -110,6 +150,13 @@ def multiStark : Except Aiur.Global Aiur.Source.Toplevel := do
   let t ← multiStarkFull
   pure (t.prune [`verify_multi_stark_proof])
 
+/-- The production FOREIGN verifier toplevel (stage 3): `multiStarkForeignFull`
+pruned to `verify_multi_stark_proof`'s call closure (also drops the foreign
+module's `fg_*` self-test entrypoints). -/
+def multiStarkForeign : Except Aiur.Global Aiur.Source.Toplevel := do
+  let t ← multiStarkForeignFull
+  pure (t.prune [`verify_multi_stark_proof])
+
 /-! ## Lean-side input assembly
 
 Callers of `verify_multi_stark_proof` (tests, benchmarks) must reproduce the
diff --git a/Ix/MultiStark/Deserialize.lean b/Ix/MultiStark/Deserialize.lean
index 96fcb9cb..fc9129a0 100644
--- a/Ix/MultiStark/Deserialize.lean
+++ b/Ix/MultiStark/Deserialize.lean
@@ -1,7 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.Core
-public import Ix.IxVM.ByteStream
 
 /-!
 # Multi-STARK proof deserializer (Aiur)
@@ -19,7 +17,7 @@ The wire format is bincode `standard().with_little_endian().with_fixed_int_encod
 * `[T; N]` / tuple            : N elements back-to-back, no length prefix
 * `Val` (Goldilocks)          : raw `u64`, 8 bytes LE (NOT reduced mod p)
 * `ExtVal` (deg-2 ext)        : `[u64; 2]`, 16 bytes LE
-* Merkle digest               : `[u64; 4]`, 32 bytes LE
+* commitments / PCS proof     : the PCS module's wire shapes (FRI: Merkle caps, `FriProof`)
 
 The proof stream is pure non-deterministic advice on IO channel 0 (never
 hashed — see `Ix/MultiStark.lean`), so the `read_proof` family reads it
@@ -30,8 +28,8 @@ materialized, which removes one memory store + one load per proof byte.
 Variable-length content loops a fixed-size read per element, exactly like
 the old stream readers looped `read_u8`.
 
-The byte-stream primitives (`read_u8`/`read_u64`/`read_count`/`read_digest`/
-`read_merkle_cap` over `ByteStream`) remain for the vk/claims streams, whose
+The byte-stream primitives (`read_u8`/`read_u64`/`read_count` over
+`ByteStream`) remain for the vk/claims streams, whose
 bytes are digest-bound and therefore flow through blake3 as materialized
 streams anyway (`read_system`, `read_claims`).
 
@@ -47,66 +45,24 @@ namespace MultiStark
 def deserialize := ⟦
   -- ==========================================================================
   -- Wire-level type mirrors of `multi-stark/src/manual_codec.rs`.
-  -- `U64`/`ByteStream` come from `IxVM.byteStream`; raw Goldilocks `Val` is the
-  -- non-canonical `u64`, kept here as the 8 little-endian bytes (`U64`).
+  -- `U64`/`ByteStream` come from `IxVM.byteStream`; a raw inner-field `Val` on
+  -- the wire is the non-canonical `u64`, kept here as 8 little-endian bytes
+  -- (`U64`). The PCS-specific shapes — `Commitment`, `PcsProof`, and their
+  -- readers `read_commitment_at`/`read_pcs_proof` — come from the merged PCS
+  -- module; this module is generic over them.
   -- ==========================================================================
 
-  -- `ExtVal = BinomialExtensionField<Goldilocks, 2> = 𝔽_p[X]/(X² - 7)`, stored
-  -- as its two NATIVE Goldilocks coefficients `[c0, c1]` (= `c0 + c1·X`) —
-  -- Aiur's field is Goldilocks, so extension arithmetic runs natively; byte
-  -- form exists only at ingest/observation boundaries (`Goldilocks.lean`).
-  type Ext = [G; 2]
-
-  -- A Merkle digest: `[u64; DIGEST_ELEMS]` with `DIGEST_ELEMS = 4`.
-  type Digest = [U64; 4]
-
-  -- Digests thread the Merkle machinery BY POINTER: a digest is 32 columns,
-  -- so every value crossing a circuit boundary (input, call output, list
-  -- node) paid 32; a pointer pays 1. `store` is content-addressed (same
-  -- digest -> same pointer), so pointer identity preserves the cross-query
-  -- compress memoization. Bytes are loaded only where actually consumed
-  -- (block assembly in mmcs_compress, cap observation, the root equality).
-  type DigestP = &Digest
-
-  -- `Commitment = MerkleCap<..>`: only the `cap: Vec<Digest>` is on the wire.
-  type MerkleCap = List‹DigestP›
+  -- `ExtVal` (the extension / challenge field) is the field module's `Ext`
+  -- (`[Val; 2]` over its `Val` representation); byte form exists only at
+  -- the ingest/observation boundaries (`val_from_bytes`/`val_to_bytes`).
 
   -- `OpenedValuesForRound<ExtVal> = Vec<Vec<Vec<ExtVal>>>`.
   type OpenedRound = List‹List‹List‹Ext›››
 
-  -- The three trace/quotient commitments at the head of a `Proof`.
+  -- The three trace/quotient commitments at the head of a `Proof`, in the
+  -- PCS module's `Commitment` representation.
   enum Commitments {
-    Mk(MerkleCap, MerkleCap, MerkleCap)
-  }
-
-  -- `BatchOpening<Val, Mmcs>`: per-round input opening of a FRI query.
-  --   opened_values : Vec<Vec<Val>>   (one row of base-field values per matrix)
-  --   opening_proof : Vec<Digest>     (Merkle authentication path)
-  enum BatchOpening {
-    Mk(List‹List‹U64››, List‹DigestP›)
-  }
-
-  -- `CommitPhaseProofStep<ExtVal, ExtMmcs>`: one folding step of a FRI query.
-  --   log_arity      : u8
-  --   sibling_values : Vec<Ext>  (arity - 1 siblings)
-  --   opening_proof  : Vec<Digest>
-  enum CommitPhaseProofStep {
-    Mk(U8, List‹Ext›, List‹DigestP›)
-  }
-
-  -- `QueryProof<ExtVal, ExtMmcs, Vec<BatchOpening<Val, Mmcs>>>`.
-  enum QueryProof {
-    Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›)
-  }
-
-  -- `PcsProof = FriProof<ExtVal, ExtMmcs, Witness = Val, ..>`.
-  --   commit_phase_commits : Vec<MerkleCap>
-  --   commit_pow_witnesses : Vec<Val>
-  --   query_proofs         : Vec<QueryProof>
-  --   final_poly           : Vec<Ext>
-  --   query_pow_witness    : Val
-  enum FriProof {
-    Mk(List‹MerkleCap›, List‹U64›, List‹QueryProof›, List‹Ext›, U64)
+    Mk(Commitment, Commitment, Commitment)
   }
 
   -- `Option<OpenedRound>` for `preprocessed_opened_values`. A dedicated
@@ -126,7 +82,7 @@ def deserialize := ⟦
       Commitments,        -- commitments
       List‹Ext›,          -- intermediate_accumulators
       List‹U8›,           -- log_degrees
-      FriProof,           -- opening_proof
+      PcsProof,           -- opening_proof (the PCS module's proof type)
       OpenedRound,        -- quotient_opened_values
       PreprocessedOpt,    -- preprocessed_opened_values
       OpenedRound,        -- stage_1_opened_values
@@ -167,9 +123,11 @@ def deserialize := ⟦
     (flatten_u64(val), s)
   }
 
-  -- Interpret a raw little-endian `u64` limb as a Goldilocks field element. The
-  -- field add/mul reduce mod p, so a non-canonical wire repr (e.g. `0` shipped
-  -- as `p = 0xFFFFFFFF00000001`) maps to the canonical field element.
+  -- Interpret a raw little-endian `u64` limb as an OUTER-field element (byte
+  -- recomposition; reduces mod the outer modulus when the limb exceeds it).
+  -- This is wire plumbing over the outer field — counts, digest-limb
+  -- comparisons — NOT inner-field ingest: semantic Goldilocks values go
+  -- through `@val_from_bytes`, which lands in the merged module's representation.
   fn limb_to_field(b: U64) -> G {
     to_field(b[0])
       + 0x100 * to_field(b[1])
@@ -181,6 +139,27 @@ def deserialize := ⟦
       + 0x100000000000000 * to_field(b[7])
   }
 
+  -- The canonical 8-LE-byte decomposition of an OUTER-field count (a value
+  -- known < 2⁶⁴ by construction: shape words, derived widths). The bytes are
+  -- prover hints; range checks + recomposition + the `< p_goldilocks` check
+  -- pin the unique decomposition in every field (under Goldilocks a count
+  -- `c < 2³² − 1` would also admit the bytes of `c + p` — rejected by
+  -- `bytes_lt_modulus`; over a > 2⁶⁴ field recomposition alone is injective and the
+  -- check is trivially satisfiable). This is the native `val_to_bytes` body
+  -- over outer values — needed because under `goldilocksForeign` the
+  -- interface's `val_to_bytes` takes the byte representation, not a count.
+  fn count_to_bytes(v: G) -> [U8; 8] {
+    let b = unconstrained_g_to_bytes(v);
+    let (c0, c1) = u8_range_check(b[0], b[1]);
+    let (c2, c3) = u8_range_check(b[2], b[3]);
+    let (c4, c5) = u8_range_check(b[4], b[5]);
+    let (c6, c7) = u8_range_check(b[6], b[7]);
+    let r = [c0, c1, c2, c3, c4, c5, c6, c7];
+    assert_eq!(@limb_to_field(r), v);
+    assert_eq!(@bytes_lt_modulus(r), 1);
+    r
+  }
+
   -- ==========================================================================
   -- Indexed proof-stream primitives: read fixed-size chunks straight from the
   -- IO arena of channel 0 at byte offset `i`, returning the advanced offset.
@@ -213,15 +192,7 @@ def deserialize := ⟦
   fn read_ext_at(i: G) -> (Ext, G) {
     let (a, j0) = #read_u64_at(i);
     let (b, j1) = #read_u64_at(j0);
-    ([@gl_val(a), @gl_val(b)], j1)
-  }
-
-  fn read_digest_at(i: G) -> (Digest, G) {
-    let (a, j0) = #read_u64_at(i);
-    let (b, j1) = #read_u64_at(j0);
-    let (c, j2) = #read_u64_at(j1);
-    let (d, j3) = #read_u64_at(j2);
-    ([a, b, c, d], j3)
+    ([@val_from_bytes(a), @val_from_bytes(b)], j1)
   }
 
   -- ==========================================================================
@@ -272,35 +243,6 @@ def deserialize := ⟦
     }
   }
 
-  fn read_digest_vec_at(i: G) -> (List‹DigestP›, G) {
-    let (n, j) = read_count_at(i);
-    read_digest_vec_at_n(j, n)
-  }
-  fn read_digest_vec_at_n(i: G, n: G) -> (List‹DigestP›, G) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = @read_digest_at(i);
-        let (rest, j2) = read_digest_vec_at_n(j, n - 1);
-        (store(ListNode.Cons(store(x), rest)), j2),
-    }
-  }
-
-  -- `Vec<Vec<Val>>` for `BatchOpening.opened_values`.
-  fn read_u64_vec_vec(i: G) -> (List‹List‹U64››, G) {
-    let (n, j) = read_count_at(i);
-    read_u64_vec_vec_n(j, n)
-  }
-  fn read_u64_vec_vec_n(i: G, n: G) -> (List‹List‹U64››, G) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = read_u64_vec(i);
-        let (rest, j2) = read_u64_vec_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
-    }
-  }
-
   -- `OpenedRound = Vec<Vec<Vec<Ext>>>`, built bottom-up from `read_ext_vec`.
   fn read_ext_vec_vec(i: G) -> (List‹List‹Ext››, G) {
     let (n, j) = read_count_at(i);
@@ -334,98 +276,13 @@ def deserialize := ⟦
   -- Struct readers (fields in declaration order, no framing).
   -- ==========================================================================
 
-  fn read_merkle_cap_at(i: G) -> (MerkleCap, G) {
-    read_digest_vec_at(i)
-  }
-  fn read_merkle_cap_vec(i: G) -> (List‹MerkleCap›, G) {
-    let (n, j) = read_count_at(i);
-    read_merkle_cap_vec_n(j, n)
-  }
-  fn read_merkle_cap_vec_n(i: G, n: G) -> (List‹MerkleCap›, G) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = @read_merkle_cap_at(i);
-        let (rest, j2) = read_merkle_cap_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
-    }
-  }
-
   fn read_commitments(i: G) -> (Commitments, G) {
-    let (stage_1_trace, j0) = @read_merkle_cap_at(i);
-    let (stage_2_trace, j1) = @read_merkle_cap_at(j0);
-    let (quotient_chunks, j2) = @read_merkle_cap_at(j1);
+    let (stage_1_trace, j0) = @read_commitment_at(i);
+    let (stage_2_trace, j1) = @read_commitment_at(j0);
+    let (quotient_chunks, j2) = @read_commitment_at(j1);
     (Commitments.Mk(stage_1_trace, stage_2_trace, quotient_chunks), j2)
   }
 
-  fn read_batch_opening(i: G) -> (BatchOpening, G) {
-    let (opened_values, j0) = @read_u64_vec_vec(i);
-    let (opening_proof, j1) = read_digest_vec_at(j0);
-    (BatchOpening.Mk(opened_values, opening_proof), j1)
-  }
-  fn read_batch_opening_vec(i: G) -> (List‹BatchOpening›, G) {
-    let (n, j) = read_count_at(i);
-    read_batch_opening_vec_n(j, n)
-  }
-  fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchOpening›, G) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = @read_batch_opening(i);
-        let (rest, j2) = read_batch_opening_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
-    }
-  }
-
-  fn read_commit_phase_step(i: G) -> (CommitPhaseProofStep, G) {
-    let (log_arity, j0) = #read_u8_at(i);
-    let (sibling_values, j1) = read_ext_vec(j0);
-    let (opening_proof, j2) = read_digest_vec_at(j1);
-    (CommitPhaseProofStep.Mk(log_arity, sibling_values, opening_proof), j2)
-  }
-  fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseProofStep›, G) {
-    let (n, j) = read_count_at(i);
-    read_commit_phase_step_vec_n(j, n)
-  }
-  fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseProofStep›, G) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = @read_commit_phase_step(i);
-        let (rest, j2) = read_commit_phase_step_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
-    }
-  }
-
-  fn read_query_proof(i: G) -> (QueryProof, G) {
-    let (input_proof, j0) = @read_batch_opening_vec(i);
-    let (commit_phase_openings, j1) = @read_commit_phase_step_vec(j0);
-    (QueryProof.Mk(input_proof, commit_phase_openings), j1)
-  }
-  fn read_query_proof_vec(i: G) -> (List‹QueryProof›, G) {
-    let (n, j) = read_count_at(i);
-    read_query_proof_vec_n(j, n)
-  }
-  fn read_query_proof_vec_n(i: G, n: G) -> (List‹QueryProof›, G) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = @read_query_proof(i);
-        let (rest, j2) = read_query_proof_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
-    }
-  }
-
-  fn read_fri_proof(i: G) -> (FriProof, G) {
-    let (commit_phase_commits, j0) = @read_merkle_cap_vec(i);
-    let (commit_pow_witnesses, j1) = read_u64_vec(j0);
-    let (query_proofs, j2) = @read_query_proof_vec(j1);
-    let (final_poly, j3) = read_ext_vec(j2);
-    let (query_pow_witness, j4) = #read_u64_at(j3);
-    (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, query_proofs,
-                 final_poly, query_pow_witness), j4)
-  }
-
   -- The activation bitmap: `Vec<bool>` on the wire (u64 count, then one
   -- 0/1 byte per circuit), kept as 0/1 field values.
   fn read_active(i: G) -> (List‹G›, G) {
@@ -461,7 +318,7 @@ def deserialize := ⟦
     let (commitments, j0) = @read_commitments(ja);
     let (intermediate_accumulators, j1) = read_ext_vec(j0);
     let (log_degrees, j2) = @read_u8_vec(j1);
-    let (opening_proof, j3) = @read_fri_proof(j2);
+    let (opening_proof, j3) = @read_pcs_proof(j2);
     let (quotient_opened_values, j4) = read_opened_round(j3);
     let (preprocessed_opened_values, j5) = read_preprocessed(j4);
     let (stage_1_opened_values, j6) = read_opened_round(j5);
diff --git a/Ix/MultiStark/Domain.lean b/Ix/MultiStark/Domain.lean
new file mode 100644
index 00000000..b17bffab
--- /dev/null
+++ b/Ix/MultiStark/Domain.lean
@@ -0,0 +1,89 @@
+module
+public import Ix.Aiur.Meta
+
+/-!
+# Evaluation domain: two-adic multiplicative cosets
+
+The trace domain of a circuit of size 2^L is the order-2^L subgroup
+(shift = 1) of the inner field's two-adic group, generated by
+`two_adic_gen(L)` — Rust's `EvaluationDomain`/`LagrangeSelectors`
+(`Radix2Coset`, shared by the FRI and KZG configs). Written against the
+field interface (`val_*`/`ext_*`): `two_adic_gen`, `pow2`, the vanishing
+polynomial `trace_vanishing`, and the Lagrange selectors at a point
+`trace_selectors` (`is_first_row`, `is_last_row`, `is_transition`,
+`inv_vanishing`).
+-/
+
+public section
+
+namespace MultiStark
+
+def twoAdicDomain := ⟦
+  -- ==========================================================================
+  -- OOD evaluation domain math (`TwoAdicMultiplicativeCoset`, Goldilocks).
+  -- The trace domain for a circuit of size 2^L is the order-2^L subgroup H
+  -- (shift = 1) generated by `two_adic_gen(L)`.
+  -- ==========================================================================
+
+  -- e^(2^k) in the extension field.
+  fn ext_exp_pow2(e: Ext, k: G) -> Ext {
+    match k {
+      0 => e,
+      _ => ext_exp_pow2(@ext_mul(e, e), k - 1),
+    }
+  }
+
+  -- `two_adic_generator(bits)` — a primitive 2^bits root of unity in
+  -- Goldilocks, derived by repeated squaring from the maximal (2^32)
+  -- generator: `g_k = g_{k+1}^2` (matches Plonky3's TWO_ADIC_GENERATORS
+  -- table, checked value-by-value). The 33-arm table cost 32 default-arm
+  -- aux + 33 selectors; the chain is one short memoized circuit — the
+  -- first call materialises ≤ 32 rows, every later call is a cache hit.
+  -- Callers must keep `bits ≤ 32` (guarded where `bits` comes from proof
+  -- advice: log_degrees in `ood_loop`, log_gmax in `pcs_verify`);
+  -- an unguarded larger value would recurse without a base case.
+  fn two_adic_gen(bits: G) -> Val {
+    match bits {
+      0  => @val_one(),
+      32 => @val_two_adic_root(),
+      _  =>
+        let g = two_adic_gen(bits + 1);
+        @val_mul(g, g),
+    }
+  }
+
+  -- Vanishing polynomial of the trace domain (shift = 1, size 2^L) at point ζ:
+  -- `Z_H(ζ) = ζ^(2^L) - 1`.
+  fn trace_vanishing(zeta: Ext, l: G) -> Ext {
+    @ext_sub(ext_exp_pow2(zeta, l), [@val_one(), @val_zero()])
+  }
+
+  -- Lagrange selectors at ζ for the trace domain (shift = 1), mirroring
+  -- `domain.rs::selectors_at_point`:
+  --   is_first_row   = Z_H(ζ) / (ζ - 1)
+  --   is_last_row    = Z_H(ζ) / (ζ - g⁻¹)
+  --   is_transition  = ζ - g⁻¹
+  --   inv_vanishing  = 1 / Z_H(ζ)
+  -- where g = two_adic_gen(L) is the subgroup generator.
+  -- 2^l as an inner-field value (l is a small log-height).
+  fn pow2(l: G) -> Val {
+    match l {
+      0 => @val_one(),
+      _ => @val_mul(@val_two(), pow2(l - 1)),
+    }
+  }
+
+  fn trace_selectors(zeta: Ext, l: G) -> (Ext, Ext, Ext, Ext) {
+    let zh = @trace_vanishing(zeta, l);
+    let ginv = @val_inverse(two_adic_gen(l));
+    let is_first = @ext_div(zh, @ext_sub(zeta, [@val_one(), @val_zero()]));
+    let is_last = @ext_div(zh, @ext_sub(zeta, [ginv, @val_zero()]));
+    let is_trans = @ext_sub(zeta, [ginv, @val_zero()]);
+    let inv_van = @ext_inverse(zh);
+    (is_first, is_last, is_trans, inv_van)
+  }
+⟧
+
+end MultiStark
+
+end
diff --git a/Ix/MultiStark/Field/GoldilocksForeign.lean b/Ix/MultiStark/Field/GoldilocksForeign.lean
new file mode 100644
index 00000000..e796939f
--- /dev/null
+++ b/Ix/MultiStark/Field/GoldilocksForeign.lean
@@ -0,0 +1,338 @@
+module
+public import Ix.Aiur.Meta
+
+/-!
+# Field interface: Goldilocks, FOREIGN form (emulated in a LARGE outer field)
+
+The same interface as `GoldilocksNative.lean` — types, values, and
+operations, base and extension — implemented WITHOUT assuming the Aiur
+outer field is Goldilocks, for an outer field LARGER than p²: the
+BLS12-381 scalar field of the KZG terminal stage (~2²⁵⁵).
+
+A `Goldilocks` element is ONE outer-field element holding its canonical
+value `< p = 2⁶⁴ − 2³² + 1`. Because the outer field is wider than 128
+bits, every operation's exact integer result fits in it, so the
+arithmetic is never computed on limbs — it is computed natively in the
+outer field and REDUCED BY CHECK:
+
+    x · y = q·p + r   with  q < p,  r < p        (x·y < p² < |F|)
+    x + y = q·p + r   with  q ∈ {0,1},  r < p    (x + y < 2p)
+
+`q`/`r` are prover hints (`unconstrained_gl_divmod`), pinned by the
+identity (one degree-2 constraint) and `< p` range checks (8 hinted
+bytes, 4 `u8_range_check` lookups, recomposition, `bytes_lt_modulus`). A
+multiplication is one row of ~8 lookups; an addition ~4 — against the
+hundreds of byte-gadget lookups of the former limb emulation. The
+inverse is hinted (`unconstrained_gl_inverse`, mod p) and pinned with one
+multiplication, replacing the 95-mul Fermat chain.
+
+Soundness needs |F| > 2·p² (no wrap in the identities). The module
+STILL RUNS under Goldilocks itself (the `fg_*` self-tests and the
+foreign-verifier interpreter gate): there the hint is `(0, v)` and the
+identities degenerate to `x·y ≡ r` with `r < p` pinning the value —
+correct results, weaker (but sufficient) argument. `p` is spelled
+`4294967295 · 4294967296 + 1` so no literal exceeds p (the exact-Nat
+constants check), evaluating to p over a large field and to 0 over
+Goldilocks.
+
+INLINE-WRAPPER CONVENTION (unchanged): the interface fns are `@`-called
+at every use site (the native form's convention — its ops splice to
+trivial arithmetic); here each heavy op is a thin `@`-inlined wrapper
+over a plain memoized `*_impl` call, so a call site costs one lookup and
+the op's columns live once in the impl's circuit. Value constructors,
+`val_is_zero` (canonical ⇒ `eq_zero`), `bytes_lt_modulus`, `val_from_u16`, and the
+byte boundaries stay genuinely inline. Exactly one of
+`goldilocksNative`/`goldilocksForeign` merges into a toplevel (same
+names by design): `multiStarkForeign` is this module under the verifier,
+the stage-3 program.
+-/
+
+public section
+
+namespace MultiStark
+
+def goldilocksForeign := ⟦
+  -- One outer-field element, canonical value < p.
+  type Val = G
+  type Ext = [Val; 2]
+
+  -- ==========================================================================
+  -- Pure values.
+  -- ==========================================================================
+  fn val_zero() -> Val { 0 }
+  fn val_one() -> Val { 1 }
+  fn val_two() -> Val { 2 }
+  -- The extension's binomial modulus: ExtGoldilocks = 𝔽_p[X]/(X² − W).
+  fn ext_w() -> Val { 7 }
+  -- The multiplicative-coset generator (Plonky3 `Goldilocks::GENERATOR`).
+  fn val_generator() -> Val { 7 }
+  -- A primitive 2^32-th root of unity (Plonky3's maximal two-adic
+  -- generator); smaller-order roots derive by squaring (`two_adic_gen`).
+  fn val_two_adic_root() -> Val { 1753635133440165772 }
+  -- A small (< 2¹⁶) constant from its two little-endian bytes — the vk's
+  -- ConstSmall ingest.
+  fn val_from_u16(lo: U8, hi: U8) -> Val {
+    to_field(lo) + 256 * to_field(hi)
+  }
+  -- p = 2⁶⁴ − 2³² + 1 = (2³² − 1)·2³² + 1, spelled in sub-p literals: the
+  -- modulus over a large outer field, 0 over Goldilocks itself.
+  fn val_modulus() -> G { 4294967295 * 4294967296 + 1 }
+
+  -- ==========================================================================
+  -- Byte boundaries and the range check (ingest/egress). The canonical LE
+  -- bytes of an outer-field value < 2⁶⁴ are a prover hint
+  -- (`unconstrained_g_to_bytes` — exact for such values), pinned by the
+  -- range checks + recomposition; `bytes_lt_modulus` then decides canonicality.
+  -- ==========================================================================
+
+  -- 1 iff the 8-byte LE integer is < p. Since p = (2³² − 1)·2³² + 1, we have
+  -- x ≥ p ⟺ (high word = 2³² − 1) ∧ (low word ≥ 1). The high word is maximal
+  -- iff its byte sum is 4·255 = 1020 (each byte is ≤ 255), and the low word
+  -- is zero iff its byte sum is zero (a sum of four bytes cannot wrap).
+  -- Inputs must be range-checked bytes.
+  fn bytes_lt_modulus(x: [U8; 8]) -> G {
+    let hi_max = eq_zero(
+      to_field(x[4]) + to_field(x[5]) + to_field(x[6]) + to_field(x[7]) - 1020);
+    let lo_zero = eq_zero(
+      to_field(x[0]) + to_field(x[1]) + to_field(x[2]) + to_field(x[3]));
+    1 - (hi_max * (1 - lo_zero))
+  }
+
+  -- The outer-field value of 8 LE bytes: Σ xᵢ·256ⁱ — exact over a large
+  -- field (< 2⁶⁴), the mod-p reduction over Goldilocks.
+  fn bytes_val(x: [U8; 8]) -> G {
+    to_field(x[0]) + 256 * to_field(x[1]) + 65536 * to_field(x[2])
+      + 16777216 * to_field(x[3]) + 4294967296 * to_field(x[4])
+      + 1099511627776 * to_field(x[5]) + 281474976710656 * to_field(x[6])
+      + 72057594037927936 * to_field(x[7])
+  }
+
+  -- Egress: the canonical 8 LE bytes of a Goldilocks value — the hinted
+  -- decomposition, range-checked, recomposed, and canonicality-checked
+  -- (two distinct byte strings < p have distinct values).
+  fn val_to_bytes(v: Val) -> [U8; 8] {
+    let b = unconstrained_g_to_bytes(v);
+    let (c0, c1) = u8_range_check(b[0], b[1]);
+    let (c2, c3) = u8_range_check(b[2], b[3]);
+    let (c4, c5) = u8_range_check(b[4], b[5]);
+    let (c6, c7) = u8_range_check(b[6], b[7]);
+    let r = [c0, c1, c2, c3, c4, c5, c6, c7];
+    assert_eq!(@bytes_val(r), v, "val_to_bytes: recomposition");
+    assert_eq!(@bytes_lt_modulus(r), 1, "val_to_bytes: canonical");
+    r
+  }
+
+  -- The range check `v < p` (returns 1): `val_to_bytes` with the bytes
+  -- discarded. Every reduced result is pinned through this.
+  fn val_range(v: G) -> G {
+    let b = unconstrained_g_to_bytes(v);
+    let (c0, c1) = u8_range_check(b[0], b[1]);
+    let (c2, c3) = u8_range_check(b[2], b[3]);
+    let (c4, c5) = u8_range_check(b[4], b[5]);
+    let (c6, c7) = u8_range_check(b[6], b[7]);
+    let r = [c0, c1, c2, c3, c4, c5, c6, c7];
+    assert_eq!(@bytes_val(r), v, "val_range: recomposition");
+    assert_eq!(@bytes_lt_modulus(r), 1, "val_range: < p");
+    1
+  }
+
+  -- Wire-limb ingest: an arbitrary 8-byte LE value (< 2⁶⁴ < 2p) — the
+  -- exact sum over a large field — reduces by one boolean multiple of p.
+  fn val_from_bytes(x: [U8; 8]) -> Val { val_from_bytes_impl(x) }
+  fn val_from_bytes_impl(x: [U8; 8]) -> Val {
+    let v = @bytes_val(x);
+    let (q, r) = unconstrained_gl_divmod(v);
+    assert_eq!(q * (q - 1), 0, "val_from_bytes: q boolean");
+    assert_eq!(v, q * @val_modulus() + r, "val_from_bytes: identity");
+    assert_eq!(@val_range(r), 1);
+    r
+  }
+
+  -- ==========================================================================
+  -- Base ring ops (mod p): compute exactly in the outer field, reduce by
+  -- check.
+  -- ==========================================================================
+
+  -- x + y < 2p: one boolean multiple of p.
+  fn val_add(x: Val, y: Val) -> Val { val_add_impl(x, y) }
+  fn val_add_impl(x: Val, y: Val) -> Val {
+    let (q, r) = unconstrained_gl_divmod(x + y);
+    assert_eq!(q * (q - 1), 0, "val_add: q boolean");
+    assert_eq!(x + y, q * @val_modulus() + r, "val_add: identity");
+    assert_eq!(@val_range(r), 1);
+    r
+  }
+
+  -- (x + p) − y ∈ (0, 2p): one boolean multiple of p. Evaluation ORDER
+  -- matters in the outer field: `x + p` first (≥ p > y), so the subtraction
+  -- never wraps — `x − y + p` would wrap at `x − y` for x < y.
+  fn val_sub(x: Val, y: Val) -> Val { val_sub_impl(x, y) }
+  fn val_sub_impl(x: Val, y: Val) -> Val {
+    let s = x + @val_modulus() - y;
+    let (q, r) = unconstrained_gl_divmod(s);
+    assert_eq!(q * (q - 1), 0, "val_sub: q boolean");
+    assert_eq!(s, q * @val_modulus() + r, "val_sub: identity");
+    assert_eq!(@val_range(r), 1);
+    r
+  }
+
+  fn val_neg(x: Val) -> Val { val_sub_impl(0, x) }
+
+  -- Canonical representation: zero iff the outer value is zero.
+  fn val_is_zero(x: Val) -> G { eq_zero(x) }
+
+  -- x · y < p²: q < p and r < p are both pinned — without the bound on q
+  -- a prover could shift mass between the two.
+  fn val_mul(x: Val, y: Val) -> Val { val_mul_impl(x, y) }
+  fn val_mul_impl(x: Val, y: Val) -> Val {
+    let (q, r) = unconstrained_gl_divmod(x * y);
+    assert_eq!(x * y, q * @val_modulus() + r, "val_mul: identity");
+    assert_eq!(@val_range(q), 1);
+    assert_eq!(@val_range(r), 1);
+    r
+  }
+
+  -- ==========================================================================
+  -- Base field inverse: hinted (mod p), pinned by one multiplication.
+  -- `x·i ≡ 1` when x ≠ 0, `i = 0` when x = 0 (matching `0⁻¹ = 0`).
+  -- ==========================================================================
+  fn val_inverse(x: Val) -> Val { val_inverse_impl(x) }
+  fn val_inverse_impl(x: Val) -> Val {
+    let i = unconstrained_gl_inverse(x);
+    assert_eq!(@val_range(i), 1);
+    let z = eq_zero(x);
+    assert_eq!(val_mul_impl(x, i), 1 - z, "val_inverse: x*i");
+    assert_eq!(i * z, 0, "val_inverse: zero case");
+    i
+  }
+
+  -- ==========================================================================
+  -- Extension algebra ExtGoldilocks = 𝔽_p[X]/(X² − 7), over the base
+  -- interface. The impl bodies are textually the native form's; the
+  -- interface fns are one-call wrappers per the module convention.
+  -- ==========================================================================
+  fn ext_add(a: Ext, b: Ext) -> Ext {
+    ext_add_impl(a, b)
+  }
+  fn ext_add_impl(a: Ext, b: Ext) -> Ext {
+    [@val_add(a[0], b[0]), @val_add(a[1], b[1])]
+  }
+  fn ext_sub(a: Ext, b: Ext) -> Ext {
+    ext_sub_impl(a, b)
+  }
+  fn ext_sub_impl(a: Ext, b: Ext) -> Ext {
+    [@val_sub(a[0], b[0]), @val_sub(a[1], b[1])]
+  }
+  fn ext_neg(a: Ext) -> Ext {
+    [@val_neg(a[0]), @val_neg(a[1])]
+  }
+  -- (a0 + a1·X)(b0 + b1·X) = (a0·b0 + 7·a1·b1) + (a0·b1 + a1·b0)·X.
+  fn ext_mul(a: Ext, b: Ext) -> Ext {
+    ext_mul_impl(a, b)
+  }
+  fn ext_mul_impl(a: Ext, b: Ext) -> Ext {
+    [@val_add(@val_mul(a[0], b[0]), @val_mul(@ext_w(), @val_mul(a[1], b[1]))),
+     @val_add(@val_mul(a[0], b[1]), @val_mul(a[1], b[0]))]
+  }
+  -- conjugate ā = a0 − a1·X, norm a·ā = a0² − 7·a1² ∈ 𝔽_p, a⁻¹ = ā / norm.
+  fn ext_inverse(a: Ext) -> Ext { ext_inverse_impl(a) }
+  fn ext_inverse_impl(a: Ext) -> Ext {
+    let norm = @val_sub(@val_mul(a[0], a[0]), @val_mul(@ext_w(), @val_mul(a[1], a[1])));
+    let ninv = @val_inverse(norm);
+    [@val_mul(a[0], ninv), @val_mul(@val_neg(a[1]), ninv)]
+  }
+  fn ext_div(a: Ext, b: Ext) -> Ext {
+    ext_mul_impl(a, ext_inverse_impl(b))
+  }
+  -- 1 iff two extension elements are equal.
+  fn ext_eq(a: Ext, b: Ext) -> G {
+    @val_is_zero(@val_sub(a[0], b[0])) * @val_is_zero(@val_sub(a[1], b[1]))
+  }
+
+  -- ==========================================================================
+  -- Self-tests (vs `gl_ops_ref` — the same vectors the native form's suite
+  -- pins, plus the boundary ops). Values are canonical integers.
+  -- ==========================================================================
+  pub fn fg_addsub_test() -> G {
+    let a = 18364758544493064720; -- 0xFEDCBA9876543210
+    let b = 1311768467463790320;  -- 0x123456789ABCDEF0
+    assert_eq!(@val_add(a, b), 1229782942542270719);
+    assert_eq!(@val_sub(a, b), 17052990077029274400);
+    assert_eq!(@val_sub(b, a), 1393753992385309921);
+    -- edge: (p-1) + 5 ≡ 4 ; 5 - (p-1) ≡ 6
+    let pm1 = 18446744069414584320;
+    assert_eq!(@val_add(pm1, 5), 4);
+    assert_eq!(@val_sub(5, pm1), 6);
+    1
+  }
+  pub fn fg_muldiv_test() -> G {
+    let a = 18364758544493064720; -- 0xFEDCBA9876543210
+    let b = 1311768467463790320;  -- 0x123456789ABCDEF0
+    assert_eq!(@val_mul(a, b), 18080541965438139092);
+    assert_eq!(@val_inverse(a), 7352237129603030369);
+    -- edge: (p-1)·5 ≡ p-5
+    let pm1 = 18446744069414584320;
+    assert_eq!(@val_mul(pm1, 5), 18446744069414584316);
+    -- a·a⁻¹ = 1 and b·b⁻¹ = 1; 0⁻¹ = 0
+    assert_eq!(@val_mul(a, @val_inverse(a)), 1);
+    assert_eq!(@val_mul(b, @val_inverse(b)), 1);
+    assert_eq!(@val_inverse(0), 0);
+    1
+  }
+  pub fn fg_ext_ops_test() -> G {
+    -- e0 = (0xFEDCBA9876543210, 0x0123456789ABCDEF), e1 = (0x1111111122222222, 0x3333333344444444)
+    let e0 = [18364758544493064720, 81985529216486895];
+    let e1 = [1229782938533634594, 3689348815028241476];
+    let s = @ext_add(e0, e1);
+    assert_eq!(s[0], 1147797413612114993);
+    assert_eq!(s[1], 3771334344244728371);
+    let m = @ext_mul(e0, e1);
+    assert_eq!(m[0], 9707086647507742218);
+    assert_eq!(m[1], 4837146220115323607);
+    let inv = @ext_inverse(e0);
+    assert_eq!(inv[0], 15624774584742309597);
+    assert_eq!(inv[1], 17771582427853906802);
+    let d = @ext_div(e0, e1);
+    assert_eq!(d[0], 4566604814623980330);
+    assert_eq!(d[1], 10158067406679060168);
+    -- e0 · e0⁻¹ = 1
+    let one = @ext_mul(e0, @ext_inverse(e0));
+    assert_eq!(one[0], 1);
+    assert_eq!(one[1], 0);
+    1
+  }
+  pub fn fg_boundary_test() -> G {
+    -- val_from_bytes reduces a non-canonical wire limb: p + 3 → 3; a canonical value
+    -- passes through.
+    let p_plus_3 = [4u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8];
+    assert_eq!(@val_from_bytes(p_plus_3), 3);
+    let a = [16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8];
+    assert_eq!(@val_from_bytes(a), 18364758544493064720);
+    -- val_to_bytes inverts val_from_bytes on canonical values.
+    let ab = @val_to_bytes(@val_from_bytes(a));
+    assert_eq!(to_field(ab[0]), 16);
+    assert_eq!(to_field(ab[7]), 254);
+    -- bytes_lt_modulus: p is not < p; p − 1 is.
+    assert_eq!(@bytes_lt_modulus([1u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]), 0);
+    assert_eq!(@bytes_lt_modulus([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]), 1);
+    -- val_is_zero on zero and one; two-adic root sanity: root^(2^31) = p − 1
+    -- (31 squarings), and squaring once more gives 1.
+    assert_eq!(@val_is_zero(@val_zero()), 1);
+    assert_eq!(@val_is_zero(@val_one()), 0);
+    let r31 = val_sq_n(@val_two_adic_root(), 31);
+    assert_eq!(r31, 18446744069414584320);
+    assert_eq!(@val_mul(r31, r31), 1);
+    1
+  }
+  -- n repeated squarings (test helper).
+  fn val_sq_n(x: Val, n: G) -> Val {
+    match n {
+      0 => x,
+      _ => val_sq_n(val_mul_impl(x, x), n - 1),
+    }
+  }
+⟧
+
+end MultiStark
+
+end
diff --git a/Ix/MultiStark/Field/GoldilocksNative.lean b/Ix/MultiStark/Field/GoldilocksNative.lean
new file mode 100644
index 00000000..f955b5f5
--- /dev/null
+++ b/Ix/MultiStark/Field/GoldilocksNative.lean
@@ -0,0 +1,178 @@
+module
+public import Ix.Aiur.Meta
+
+/-!
+# Field interface: Goldilocks, NATIVE form (`Val = G`)
+
+The single module where the recursive verifier assumes the Aiur outer
+field IS Goldilocks (`aiur::G = p3_goldilocks`): the inner field's
+types, values, and operations, base and extension. Everything
+downstream (`Pcs.lean`, `Verifier.lean`) does its inner-field
+arithmetic exclusively through calls into this interface — always
+inlined (`@val_add(..)`, `@ext_mul(..)`), so every function here splices
+away at compile time.
+
+The point of the indirection: a future `GoldilocksForeign.lean` will
+provide the same interface over a non-Goldilocks outer field (e.g. the
+BLS12-381 scalar field for the KZG terminal stage), where a `Goldilocks`
+value is a different representation and the operations are emulated.
+Swapping fields is then a matter of choosing which module to merge into
+the toplevel — no verifier-side changes.
+
+Contents:
+
+- the representation types: `Goldilocks` (native: `G` itself) and the
+  degree-2 extension `ExtGoldilocks = 𝔽_p[X]/(X² − 7)` (a pair
+  `[c0, c1] = c0 + c1·X`);
+- pure values: `val_zero`/`val_one`/`val_two`, the binomial modulus `ext_w`
+  (X² = 7), the multiplicative-coset generator `val_generator` (7), and
+  the maximal two-adic root `val_two_adic_root` (order 2^32);
+- base ring ops `val_add`/`val_sub`/`val_neg`/`val_mul`, the zero test
+  `val_is_zero` (a native boolean), and the hinted inverse `val_inverse`;
+- the extension algebra `ext_add`/`ext_sub`/`ext_neg`/`ext_mul`/
+  `ext_inverse`/`ext_div`/`ext_eq` (inverses reduce to the hinted base
+  inverse via conjugate/norm);
+- the byte boundaries `val_from_bytes` (ingest: wire limbs → value, the field
+  sum wraps mod p — exactly the reduction), `bytes_lt_modulus` (canonicality),
+  and `val_to_bytes` (egress: hinted canonical LE decomposition, pinned
+  by range checks + recomposition + canonicality).
+
+The extension algebra is validated against `multi-stark`'s native
+Goldilocks (`gl_ops_ref` in `multi-stark/src/types.rs`) via the
+`multi-stark` self-test suite.
+-/
+
+public section
+
+namespace MultiStark
+
+def goldilocksNative := ⟦
+  type Val = G
+  type Ext = [Val; 2]
+
+  -- ==========================================================================
+  -- Pure values.
+  -- ==========================================================================
+  fn val_zero() -> Val { 0 }
+  fn val_one() -> Val { 1 }
+  fn val_two() -> Val { 2 }
+  -- The extension's binomial modulus: ExtGoldilocks = 𝔽_p[X]/(X² − W).
+  fn ext_w() -> Val { 7 }
+  -- The multiplicative-coset generator (Plonky3 `Goldilocks::GENERATOR`).
+  fn val_generator() -> Val { 7 }
+  -- A primitive 2^32-th root of unity (Plonky3's maximal two-adic
+  -- generator); smaller-order roots derive by squaring (`two_adic_gen`).
+  fn val_two_adic_root() -> Val { 1753635133440165772 }
+  -- A small (< 2¹⁶) constant from its two little-endian bytes — the vk's
+  -- ConstSmall ingest (byte sums cannot wrap, and 2¹⁶ < p in every field).
+  fn val_from_u16(lo: U8, hi: U8) -> Val {
+    to_field(lo) + 256 * to_field(hi)
+  }
+
+  -- ==========================================================================
+  -- Ring operations. Native: the outer field's own `+`/`-`/`*`.
+  -- ==========================================================================
+  fn val_add(a: Val, b: Val) -> Val { a + b }
+  fn val_sub(a: Val, b: Val) -> Val { a - b }
+  fn val_neg(a: Val) -> Val { 0 - a }
+  fn val_mul(a: Val, b: Val) -> Val { a * b }
+
+  -- 1 iff the value is zero (as a native boolean flag).
+  fn val_is_zero(a: Val) -> G { eq_zero(a) }
+
+  -- ==========================================================================
+  -- Base field inverse: hinted, verified with one multiplication.
+  -- `t = x·i − 1; x·t == 0 ∧ i·t == 0` forces `i = x⁻¹` when `x ≠ 0` (first
+  -- assert gives x·i = 1) and `i = 0` when `x = 0` (t = −1, second assert).
+  -- Matches the reference semantics `0⁻¹ = 0` (Fermat: 0^(p−2) = 0).
+  -- ==========================================================================
+  fn val_inverse(x: Val) -> Val {
+    let iv = unconstrained_g_inverse(x);
+    let t = (x * iv) - 1;
+    assert_eq!(x * t, 0);
+    assert_eq!(iv * t, 0);
+    iv
+  }
+
+  -- ==========================================================================
+  -- Byte boundaries (ingest/egress). Native-representation-specific by
+  -- nature: they define what a `Goldilocks` value IS on the wire.
+  -- ==========================================================================
+
+  -- The native field value of 8 LE bytes: `Σ xᵢ·256ⁱ` (mod p). For an
+  -- arbitrary 8-byte value (< 2⁶⁴ < 2p) the field sum wraps at most once,
+  -- yielding exactly the reduced representative — so this is both the
+  -- canonical-bytes recomposition AND the wire-limb reduction.
+  fn val_from_bytes(x: [U8; 8]) -> G {
+    to_field(x[0]) + 256 * to_field(x[1]) + 65536 * to_field(x[2])
+      + 16777216 * to_field(x[3]) + 4294967296 * to_field(x[4])
+      + 1099511627776 * to_field(x[5]) + 281474976710656 * to_field(x[6])
+      + 72057594037927936 * to_field(x[7])
+  }
+
+  -- 1 iff the 8-byte LE integer is < p. Since p = (2³² − 1)·2³² + 1, we have
+  -- x ≥ p ⟺ (high word = 2³² − 1) ∧ (low word ≥ 1). The high word is maximal
+  -- iff its byte sum is 4·255 = 1020 (each byte is ≤ 255), and the low word
+  -- is zero iff its byte sum is zero (a sum of four bytes cannot wrap).
+  -- Inputs must be range-checked bytes. (Used by the challenger's rejection
+  -- sampling, which works on raw sampled bytes.)
+  fn bytes_lt_modulus(x: [U8; 8]) -> G {
+    let hi_max = eq_zero(
+      to_field(x[4]) + to_field(x[5]) + to_field(x[6]) + to_field(x[7]) - 1020);
+    let lo_zero = eq_zero(
+      to_field(x[0]) + to_field(x[1]) + to_field(x[2]) + to_field(x[3]));
+    1 - (hi_max * (1 - lo_zero))
+  }
+
+  -- Decompose a native field value into its canonical 8 LE bytes (egress:
+  -- challenger observations). The bytes are prover hints; the range checks +
+  -- recomposition equality + canonicality check pin the unique canonical
+  -- decomposition (two distinct byte strings < p have distinct field values).
+  fn val_to_bytes(v: G) -> [U8; 8] {
+    let b = unconstrained_g_to_bytes(v);
+    let (c0, c1) = u8_range_check(b[0], b[1]);
+    let (c2, c3) = u8_range_check(b[2], b[3]);
+    let (c4, c5) = u8_range_check(b[4], b[5]);
+    let (c6, c7) = u8_range_check(b[6], b[7]);
+    let r = [c0, c1, c2, c3, c4, c5, c6, c7];
+    assert_eq!(@val_from_bytes(r), v);
+    assert_eq!(@bytes_lt_modulus(r), 1);
+    r
+  }
+
+  -- ==========================================================================
+  -- Extension algebra ExtGoldilocks = 𝔽_p[X]/(X² − 7), over the base
+  -- interface (no raw arithmetic below this line).
+  -- ==========================================================================
+  fn ext_add(a: Ext, b: Ext) -> Ext {
+    [@val_add(a[0], b[0]), @val_add(a[1], b[1])]
+  }
+  fn ext_sub(a: Ext, b: Ext) -> Ext {
+    [@val_sub(a[0], b[0]), @val_sub(a[1], b[1])]
+  }
+  fn ext_neg(a: Ext) -> Ext {
+    [@val_neg(a[0]), @val_neg(a[1])]
+  }
+  -- (a0 + a1·X)(b0 + b1·X) = (a0·b0 + 7·a1·b1) + (a0·b1 + a1·b0)·X.
+  fn ext_mul(a: Ext, b: Ext) -> Ext {
+    [@val_add(@val_mul(a[0], b[0]), @val_mul(@ext_w(), @val_mul(a[1], b[1]))),
+     @val_add(@val_mul(a[0], b[1]), @val_mul(a[1], b[0]))]
+  }
+  -- conjugate ā = a0 − a1·X, norm a·ā = a0² − 7·a1² ∈ 𝔽_p, a⁻¹ = ā / norm.
+  fn ext_inverse(a: Ext) -> Ext {
+    let norm = @val_sub(@val_mul(a[0], a[0]), @val_mul(@ext_w(), @val_mul(a[1], a[1])));
+    let ninv = @val_inverse(norm);
+    [@val_mul(a[0], ninv), @val_mul(@val_neg(a[1]), ninv)]
+  }
+  fn ext_div(a: Ext, b: Ext) -> Ext {
+    @ext_mul(a, @ext_inverse(b))
+  }
+  -- 1 iff two extension elements are equal.
+  fn ext_eq(a: Ext, b: Ext) -> G {
+    @val_is_zero(@val_sub(a[0], b[0])) * @val_is_zero(@val_sub(a[1], b[1]))
+  }
+⟧
+
+end MultiStark
+
+end
diff --git a/Ix/MultiStark/Goldilocks.lean b/Ix/MultiStark/Goldilocks.lean
deleted file mode 100644
index d9873ac6..00000000
--- a/Ix/MultiStark/Goldilocks.lean
+++ /dev/null
@@ -1,137 +0,0 @@
-module
-public import Ix.Aiur.Meta
-
-/-!
-# Goldilocks field arithmetic on the native field (`Goldilocks = G`)
-
-The recursive verifier computes on the *inner* proof's field (Goldilocks) —
-and Aiur's outer field IS Goldilocks (`aiur::G = p3_goldilocks`), so the
-arithmetic runs directly on native `+`/`*`. A `Goldilocks` element is a
-plain field value (canonical by construction — `G` is the field), and
-`ExtGoldilocks = [G; 2]` is the degree-2 extension `𝔽_p[X]/(X² − 7)`.
-
-Byte form exists only at true boundaries:
-
-- **ingest**: wire limbs (`U64`, 8 LE bytes, possibly non-canonical) fold
-  into native values with `gl_val`/`limb_to_field` (the field sum wraps
-  mod p — exactly the reduction);
-- **egress**: challenger observations need the canonical LE bytes;
-  `gl_to_bytes` decomposes a native value via the `unconstrained_g_to_bytes`
-  hint, pinned by u8 range checks, a recomposition equality, and a
-  canonicality (`< p`) check — forcing the unique canonical decomposition.
-
-Inverses are hinted (`unconstrained_g_inverse`) and verified with one
-multiplication, never computed.
-
-If Aiur is ever compiled to a different outer field (e.g. the BLS scalar
-field), this module must be swapped for a field-agnostic byte-limb
-implementation (see this file's git history for a complete one, validated
-byte-for-byte against `multi-stark`'s `gl_ops_ref`).
-
-Validated against `multi-stark`'s native Goldilocks (`gl_ops_ref` in
-`multi-stark/src/types.rs`) via the `multi-stark` self-test suite.
--/
-
-public section
-
-namespace MultiStark
-
-def goldilocks := ⟦
-  type Goldilocks = G
-  type ExtGoldilocks = [G; 2]
-
-  -- The native field value of 8 LE bytes: `Σ xᵢ·256ⁱ` (mod p). For an
-  -- arbitrary 8-byte value (< 2⁶⁴ < 2p) the field sum wraps at most once,
-  -- yielding exactly the reduced representative — so this is both the
-  -- canonical-bytes recomposition AND the wire-limb reduction.
-  fn gl_val(x: [U8; 8]) -> G {
-    to_field(x[0]) + 256 * to_field(x[1]) + 65536 * to_field(x[2])
-      + 16777216 * to_field(x[3]) + 4294967296 * to_field(x[4])
-      + 1099511627776 * to_field(x[5]) + 281474976710656 * to_field(x[6])
-      + 72057594037927936 * to_field(x[7])
-  }
-
-  -- 1 iff the 8-byte LE integer is < p. Since p = (2³² − 1)·2³² + 1, we have
-  -- x ≥ p ⟺ (high word = 2³² − 1) ∧ (low word ≥ 1). The high word is maximal
-  -- iff its byte sum is 4·255 = 1020 (each byte is ≤ 255), and the low word
-  -- is zero iff its byte sum is zero (a sum of four bytes cannot wrap).
-  -- Inputs must be range-checked bytes. (Used by the challenger's rejection
-  -- sampling, which works on raw sampled bytes.)
-  fn gl_lt_p(x: [U8; 8]) -> G {
-    let hi_max = eq_zero(
-      to_field(x[4]) + to_field(x[5]) + to_field(x[6]) + to_field(x[7]) - 1020);
-    let lo_zero = eq_zero(
-      to_field(x[0]) + to_field(x[1]) + to_field(x[2]) + to_field(x[3]));
-    1 - (hi_max * (1 - lo_zero))
-  }
-
-  -- Decompose a native field value into its canonical 8 LE bytes (egress:
-  -- challenger observations). The bytes are prover hints; the range checks +
-  -- recomposition equality + canonicality check pin the unique canonical
-  -- decomposition (two distinct byte strings < p have distinct field values).
-  fn gl_to_bytes(v: G) -> [U8; 8] {
-    let b = unconstrained_g_to_bytes(v);
-    let (c0, c1) = u8_range_check(b[0], b[1]);
-    let (c2, c3) = u8_range_check(b[2], b[3]);
-    let (c4, c5) = u8_range_check(b[4], b[5]);
-    let (c6, c7) = u8_range_check(b[6], b[7]);
-    let r = [c0, c1, c2, c3, c4, c5, c6, c7];
-    assert_eq!(@gl_val(r), v);
-    assert_eq!(@gl_lt_p(r), 1);
-    r
-  }
-
-  -- ==========================================================================
-  -- Base field inverse: hinted, verified with one multiplication.
-  -- `t = x·i − 1; x·t == 0 ∧ i·t == 0` forces `i = x⁻¹` when `x ≠ 0` (first
-  -- assert gives x·i = 1) and `i = 0` when `x = 0` (t = −1, second assert).
-  -- Matches the reference semantics `0⁻¹ = 0` (Fermat: 0^(p−2) = 0).
-  -- Always called inlined (`@gl_inverse`), so it compiles to no circuit.
-  -- ==========================================================================
-  fn gl_inverse(x: Goldilocks) -> Goldilocks {
-    let iv = unconstrained_g_inverse(x);
-    let t = (x * iv) - 1;
-    assert_eq!(x * t, 0);
-    assert_eq!(iv * t, 0);
-    iv
-  }
-
-  -- ==========================================================================
-  -- Extension field ExtGoldilocks = 𝔽_p[X]/(X² − 7), native end-to-end.
-  -- ==========================================================================
-  fn eg_add(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks {
-    [a[0] + b[0], a[1] + b[1]]
-  }
-  fn eg_sub(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks {
-    [a[0] - b[0], a[1] - b[1]]
-  }
-  fn eg_neg(a: ExtGoldilocks) -> ExtGoldilocks {
-    [0 - a[0], 0 - a[1]]
-  }
-  -- (a0 + a1·X)(b0 + b1·X) = (a0·b0 + 7·a1·b1) + (a0·b1 + a1·b0)·X.
-  fn eg_mul(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks {
-    [(a[0] * b[0]) + (7 * (a[1] * b[1])), (a[0] * b[1]) + (a[1] * b[0])]
-  }
-  -- conjugate ā = a0 − a1·X, norm a·ā = a0² − 7·a1² ∈ 𝔽_p, a⁻¹ = ā / norm.
-  -- The norm inverse is hinted and pinned like `gl_inverse`.
-  fn eg_inverse(a: ExtGoldilocks) -> ExtGoldilocks {
-    let norm = (a[0] * a[0]) - (7 * (a[1] * a[1]));
-    let ninv = unconstrained_g_inverse(norm);
-    let t = (norm * ninv) - 1;
-    assert_eq!(norm * t, 0);
-    assert_eq!(ninv * t, 0);
-    [a[0] * ninv, (0 - a[1]) * ninv]
-  }
-  fn eg_div(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks {
-    @eg_mul(a, @eg_inverse(b))
-  }
-  -- 1 iff two extension elements are equal.
-  fn eg_eq(a: ExtGoldilocks, b: ExtGoldilocks) -> G {
-    eq_zero(a[0] - b[0]) * eq_zero(a[1] - b[1])
-  }
-
-⟧
-
-end MultiStark
-
-end
diff --git a/Ix/MultiStark/Keccak.lean b/Ix/MultiStark/Keccak.lean
index a2eb7e73..9fb884db 100644
--- a/Ix/MultiStark/Keccak.lean
+++ b/Ix/MultiStark/Keccak.lean
@@ -1,7 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.Core
-public import Ix.IxVM.ByteStream
 
 /-!
 # Keccak-256 in Aiur
diff --git a/Ix/MultiStark/Pcs.lean b/Ix/MultiStark/Pcs/Fri.lean
similarity index 80%
rename from Ix/MultiStark/Pcs.lean
rename to Ix/MultiStark/Pcs/Fri.lean
index 82a147c2..5d8c6c99 100644
--- a/Ix/MultiStark/Pcs.lean
+++ b/Ix/MultiStark/Pcs/Fri.lean
@@ -1,10 +1,8 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.MultiStark.Deserialize
-public import Ix.MultiStark.Keccak
 
 /-!
-# PCS (FRI) verification
+# PCS interface: FRI implementation
 
 Ports `multi-stark/src/verifier.rs`'s `pcs.verify(...)` — a `TwoAdicFriPcs` FRI
 verification: Merkle `verify_batch` (binary tree, multi-height injection), the
@@ -29,7 +27,247 @@ public section
 
 namespace MultiStark
 
-def pcs := ⟦
+def pcsFri := ⟦
+  -- ==========================================================================
+  -- The PCS interface, FRI implementation (`TwoAdicFriPcs` over a Blake3
+  -- `MerkleTreeMmcs`): the types and names the generic verifier refers to.
+  -- ==========================================================================
+  -- A Merkle digest: `[u64; DIGEST_ELEMS]` with `DIGEST_ELEMS = 4`.
+  type Digest = [U64; 4]
+
+  -- Digests thread the Merkle machinery BY POINTER: a digest is 32 columns,
+  -- so every value crossing a circuit boundary (input, call output, list
+  -- node) paid 32; a pointer pays 1. `store` is content-addressed (same
+  -- digest -> same pointer), so pointer identity preserves the cross-query
+  -- compress memoization. Bytes are loaded only where actually consumed
+  -- (block assembly in mmcs_compress, cap observation, the root equality).
+  type DigestP = &Digest
+
+  -- `Commitment = MerkleCap<..>`: only the `cap: Vec<Digest>` is on the wire.
+  type MerkleCap = List‹DigestP›
+
+  -- Interface type: the PCS commitment on the wire — a Merkle cap.
+  type Commitment = MerkleCap
+  -- `BatchOpening<Val, Mmcs>`: per-round input opening of a FRI query.
+  --   opened_values : Vec<Vec<Val>>   (one row of base-field values per matrix)
+  --   opening_proof : Vec<Digest>     (Merkle authentication path)
+  enum BatchOpening {
+    Mk(List‹List‹U64››, List‹DigestP›)
+  }
+
+  -- `CommitPhaseProofStep<ExtVal, ExtMmcs>`: one folding step of a FRI query.
+  --   log_arity      : u8
+  --   sibling_values : Vec<Ext>  (arity - 1 siblings)
+  --   opening_proof  : Vec<Digest>
+  enum CommitPhaseProofStep {
+    Mk(U8, List‹Ext›, List‹DigestP›)
+  }
+
+  -- `QueryProof<ExtVal, ExtMmcs, Vec<BatchOpening<Val, Mmcs>>>`.
+  enum QueryProof {
+    Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›)
+  }
+
+  -- `PcsProof = FriProof<ExtVal, ExtMmcs, Witness = Val, ..>`.
+  --   commit_phase_commits : Vec<MerkleCap>
+  --   commit_pow_witnesses : Vec<Val>
+  --   query_proofs         : Vec<QueryProof>
+  --   final_poly           : Vec<Ext>
+  --   query_pow_witness    : Val
+  enum FriProof {
+    Mk(List‹MerkleCap›, List‹U64›, List‹QueryProof›, List‹Ext›, U64)
+  }
+
+  -- Interface type: the PCS opening proof — the FRI proof.
+  type PcsProof = FriProof
+
+  -- Interface type: the PCS/config parameters the vk opens with —
+  -- log_blowup, cap_height, log_final_poly_len, max_log_arity, num_queries,
+  -- commit_proof_of_work_bits, query_proof_of_work_bits (the commitment +
+  -- FRI parameters the config and its challenger seed were built from).
+  enum PcsParams { Mk(G, G, G, G, G, G, G) }
+
+  -- The empty commitment (observes nothing): a missing preprocessed commit.
+  fn pcs_empty_commitment() -> Commitment { store(ListNode.Nil) }
+
+  -- ==========================================================================
+  -- Proof-stream readers for the PCS shapes (indexed channel-0 reads; the
+  -- generic readers `read_u64_at`/`read_count_at`/`read_ext_vec`/... come
+  -- from the deserializer).
+  -- ==========================================================================
+  fn read_digest_at(i: G) -> (Digest, G) {
+    let (a, j0) = #read_u64_at(i);
+    let (b, j1) = #read_u64_at(j0);
+    let (c, j2) = #read_u64_at(j1);
+    let (d, j3) = #read_u64_at(j2);
+    ([a, b, c, d], j3)
+  }
+
+  fn read_digest_vec_at(i: G) -> (List‹DigestP›, G) {
+    let (n, j) = read_count_at(i);
+    read_digest_vec_at_n(j, n)
+  }
+  fn read_digest_vec_at_n(i: G, n: G) -> (List‹DigestP›, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = @read_digest_at(i);
+        let (rest, j2) = read_digest_vec_at_n(j, n - 1);
+        (store(ListNode.Cons(store(x), rest)), j2),
+    }
+  }
+
+  -- `Vec<Vec<Val>>` for `BatchOpening.opened_values`.
+  fn read_u64_vec_vec(i: G) -> (List‹List‹U64››, G) {
+    let (n, j) = read_count_at(i);
+    read_u64_vec_vec_n(j, n)
+  }
+  fn read_u64_vec_vec_n(i: G, n: G) -> (List‹List‹U64››, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = read_u64_vec(i);
+        let (rest, j2) = read_u64_vec_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
+    }
+  }
+
+  -- Interface: read one commitment at proof offset `i`.
+  fn read_commitment_at(i: G) -> (Commitment, G) {
+    read_digest_vec_at(i)
+  }
+  fn read_merkle_cap_vec(i: G) -> (List‹MerkleCap›, G) {
+    let (n, j) = read_count_at(i);
+    read_merkle_cap_vec_n(j, n)
+  }
+  fn read_merkle_cap_vec_n(i: G, n: G) -> (List‹MerkleCap›, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = @read_commitment_at(i);
+        let (rest, j2) = read_merkle_cap_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
+    }
+  }
+
+  fn read_batch_opening(i: G) -> (BatchOpening, G) {
+    let (opened_values, j0) = @read_u64_vec_vec(i);
+    let (opening_proof, j1) = read_digest_vec_at(j0);
+    (BatchOpening.Mk(opened_values, opening_proof), j1)
+  }
+  fn read_batch_opening_vec(i: G) -> (List‹BatchOpening›, G) {
+    let (n, j) = read_count_at(i);
+    read_batch_opening_vec_n(j, n)
+  }
+  fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchOpening›, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = @read_batch_opening(i);
+        let (rest, j2) = read_batch_opening_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
+    }
+  }
+
+  fn read_commit_phase_step(i: G) -> (CommitPhaseProofStep, G) {
+    let (log_arity, j0) = #read_u8_at(i);
+    let (sibling_values, j1) = read_ext_vec(j0);
+    let (opening_proof, j2) = read_digest_vec_at(j1);
+    (CommitPhaseProofStep.Mk(log_arity, sibling_values, opening_proof), j2)
+  }
+  fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseProofStep›, G) {
+    let (n, j) = read_count_at(i);
+    read_commit_phase_step_vec_n(j, n)
+  }
+  fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseProofStep›, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = @read_commit_phase_step(i);
+        let (rest, j2) = read_commit_phase_step_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
+    }
+  }
+
+  fn read_query_proof(i: G) -> (QueryProof, G) {
+    let (input_proof, j0) = @read_batch_opening_vec(i);
+    let (commit_phase_openings, j1) = @read_commit_phase_step_vec(j0);
+    (QueryProof.Mk(input_proof, commit_phase_openings), j1)
+  }
+  fn read_query_proof_vec(i: G) -> (List‹QueryProof›, G) {
+    let (n, j) = read_count_at(i);
+    read_query_proof_vec_n(j, n)
+  }
+  fn read_query_proof_vec_n(i: G, n: G) -> (List‹QueryProof›, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = @read_query_proof(i);
+        let (rest, j2) = read_query_proof_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
+    }
+  }
+
+  -- Interface: read the PCS proof at proof offset `i`.
+  fn read_pcs_proof(i: G) -> (PcsProof, G) {
+    let (commit_phase_commits, j0) = @read_merkle_cap_vec(i);
+    let (commit_pow_witnesses, j1) = read_u64_vec(j0);
+    let (query_proofs, j2) = @read_query_proof_vec(j1);
+    let (final_poly, j3) = read_ext_vec(j2);
+    let (query_pow_witness, j4) = #read_u64_at(j3);
+    (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, query_proofs,
+                 final_poly, query_pow_witness), j4)
+  }
+
+
+  -- ==========================================================================
+  -- Verifying-key readers for the PCS shapes (materialized `ByteStream`; the
+  -- `read_vk_*` primitives come from the vk deserializer).
+  -- ==========================================================================
+  fn read_vk_digest(i: ByteStream) -> (Digest, ByteStream) {
+    let (a, j0) = read_vk_u64(i);
+    let (b, j1) = read_vk_u64(j0);
+    let (c, j2) = read_vk_u64(j1);
+    let (d, j3) = read_vk_u64(j2);
+    ([a, b, c, d], j3)
+  }
+  fn read_vk_cap_n(i: ByteStream, n: G) -> (MerkleCap, ByteStream) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = @read_vk_digest(i);
+        let (rest, j2) = read_vk_cap_n(j, n - 1);
+        (store(ListNode.Cons(store(x), rest)), j2),
+    }
+  }
+
+
+  -- Interface: the commitment as serialized in the vk (u16 count + caps).
+  fn read_vk_commitment(i: ByteStream) -> (Commitment, ByteStream) {
+    let (n, j1) = read_vk_u16(i);
+    read_vk_cap_n(j1, n)
+  }
+
+  -- The 7 protocol parameters, both as field values (for the verifier logic)
+  -- and as u64 limbs (their LE bytes seed the challenger).
+  -- Interface: the PCS parameters (and their u64 limbs, whose LE bytes seed
+  -- the challenger).
+  fn read_pcs_params(i: ByteStream) -> (PcsParams, List‹U64›, ByteStream) {
+    let (p0, l0, j0) = read_vk_u16_limb(i);
+    let (p1, l1, j1) = read_vk_u16_limb(j0);
+    let (p2, l2, j2) = read_vk_u16_limb(j1);
+    let (p3, l3, j3) = read_vk_u16_limb(j2);
+    let (p4, l4, j4) = read_vk_u16_limb(j3);
+    let (p5, l5, j5) = read_vk_u16_limb(j4);
+    let (p6, l6, j6) = read_vk_u16_limb(j5);
+    (PcsParams.Mk(p0, p1, p2, p3, p4, p5, p6),
+     store(ListNode.Cons(l0, store(ListNode.Cons(l1, store(ListNode.Cons(l2,
+     store(ListNode.Cons(l3, store(ListNode.Cons(l4, store(ListNode.Cons(l5,
+     store(ListNode.Cons(l6, store(ListNode.Nil))))))))))))))),
+     j6)
+  }
+
+
   -- ==========================================================================
   -- Blake3 MMCS hash primitives.
   --
@@ -360,7 +598,7 @@ def pcs := ⟦
   fn canon_lanes(l: List‹U64›) -> List‹U64› {
     match load(l) {
       ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(x, rest) => store(ListNode.Cons(@gl_to_bytes(@gl_val(x)), canon_lanes(rest))),
+      ListNode.Cons(x, rest) => store(ListNode.Cons(@val_to_bytes(@val_from_bytes(x)), canon_lanes(rest))),
     }
   }
   -- ==========================================================================
@@ -394,7 +632,7 @@ def pcs := ⟦
   -- non-empty, so advancing to the next row always yields a lane).
   fn rows_pop(cur: List‹U64›, rows: List‹List‹U64››) -> (U64, List‹U64›, List‹List‹U64››, G) {
     match load(cur) {
-      ListNode.Cons(x, rest) => (@gl_to_bytes(@gl_val(x)), rest, rows, 1),
+      ListNode.Cons(x, rest) => (@val_to_bytes(@val_from_bytes(x)), rest, rows, 1),
       ListNode.Nil => match load(rows) {
         ListNode.Nil => ([0u8; 8], cur, rows, 0),
         ListNode.Cons(r, rrest) => rows_pop(r, rrest),
@@ -538,14 +776,14 @@ def pcs := ⟦
 
   -- base^(Σ bits_i · 2^i), bits LSB-first (square-and-multiply over the bits).
   -- `base` is a native Goldilocks element; `bits` is a native bit list.
-  fn exp_by_bits(base: Goldilocks, bits: List‹G›) -> Goldilocks {
+  fn exp_by_bits(base: Val, bits: List‹G›) -> Val {
     match load(bits) {
-      ListNode.Nil => 1,
+      ListNode.Nil => @val_one(),
       ListNode.Cons(b, rest) =>
-        let half = exp_by_bits(base * base, rest);
+        let half = exp_by_bits(@val_mul(base, base), rest);
         match b {
           0 => half,
-          _ => base * half,
+          _ => @val_mul(base, half),
         },
     }
   }
@@ -555,10 +793,10 @@ def pcs := ⟦
   fn fri_fold2(index_bits: List‹G›, log_height: G, beta: Ext, e0: Ext, e1: Ext) -> Ext {
     let g = two_adic_gen(log_height + 1);
     let s = exp_by_bits(g, glist_rev(index_bits, store(ListNode.Nil)));
-    let two_s = s + s;
-    let t1 = @eg_div(@eg_add(e0, e1), [2, 0]);
-    let t2 = @eg_mul(beta, @eg_div(@eg_sub(e0, e1), [two_s, 0]));
-    @eg_add(t1, t2)
+    let two_s = @val_add(s, s);
+    let t1 = @ext_div(@ext_add(e0, e1), [@val_two(), @val_zero()]);
+    let t2 = @ext_mul(beta, @ext_div(@ext_sub(e0, e1), [two_s, @val_zero()]));
+    @ext_add(t1, t2)
   }
 
   -- ==========================================================================
@@ -576,25 +814,26 @@ def pcs := ⟦
 
   -- The base-field query domain point x. `index_bits` = low-`log_height` index
   -- bits, LSB first (so reverse_bits_len = reversing the list).
-  fn ro_x(index_bits: List‹G›, log_height: G) -> Goldilocks {
-    7 * exp_by_bits(two_adic_gen(log_height), glist_rev(index_bits, store(ListNode.Nil)))
+  fn ro_x(index_bits: List‹G›, log_height: G) -> Val {
+    @val_mul(@val_generator(), exp_by_bits(two_adic_gen(log_height), glist_rev(index_bits, store(ListNode.Nil))))
   }
 
   -- Accumulate one matrix-point's column contributions WITHOUT the quotient
   -- factor: `s = Σᵢ apᵢ·(p_zᵢ − p_xᵢ)`. The caller multiplies by
   -- `q = 1/(z − x)` once per matrix-point (it is constant across the
   -- point's columns), saving an ext mul per column. `p_x` is the RAW wire
-  -- lane list — `limb_to_field` reduces mod p as pure wiring, so no
-  -- intermediate `List‹Goldilocks›` is ever materialized (the former
-  -- `lanes_to_gl` pass and its per-lane stores/loads).
+  -- lane list — `val_from_bytes` reduces each limb into the inner-field
+  -- representation as it is consumed, so no intermediate `List‹Goldilocks›`
+  -- is ever materialized (the former `lanes_to_gl` pass and its per-lane
+  -- stores/loads).
   fn ro_fold(p_x: List‹U64›, p_z: List‹Ext›, alpha: Ext, s: Ext, ap: Ext)
       -> (Ext, Ext) {
     match load(p_x) {
       ListNode.Nil => (s, ap),
       ListNode.Cons(lane, pxr) =>
         let &ListNode.Cons(pz, pzr) = p_z;
-        let term = @eg_mul(ap, @eg_sub(pz, [@limb_to_field(lane), 0]));
-        ro_fold(pxr, pzr, alpha, @eg_add(s, term), @eg_mul(ap, alpha)),
+        let term = @ext_mul(ap, @ext_sub(pz, [@val_from_bytes(lane), @val_zero()]));
+        ro_fold(pxr, pzr, alpha, @ext_add(s, term), @ext_mul(ap, alpha)),
     }
   }
 
@@ -625,7 +864,7 @@ def pcs := ⟦
   fn ext_row_onto(row: List‹Ext›, tail: ByteStream) -> ByteStream {
     match load(row) {
       ListNode.Nil => tail,
-      ListNode.Cons(e, rest) => b8_onto(@gl_to_bytes(e[0]), b8_onto(@gl_to_bytes(e[1]), ext_row_onto(rest, tail))),
+      ListNode.Cons(e, rest) => b8_onto(@val_to_bytes(e[0]), b8_onto(@val_to_bytes(e[1]), ext_row_onto(rest, tail))),
     }
   }
   fn points_onto(pts: List‹List‹Ext››, tail: ByteStream) -> ByteStream {
@@ -678,10 +917,10 @@ def pcs := ⟦
       ListNode.Nil => (store(ListNode.Nil), input),
       ListNode.Cons(c, rest) =>
         let &ListNode.Cons(w, wrest) = witnesses;
-        let (i1, o1) = pcs_check_witness(snoc_cap(input, c), w, bits);
+        let (i1, o1) = pcs_check_witness(snoc_commitment(input, c), w, bits);
         let (b0, b1, i2, _o) = ch_sample_ext(i1, o1);
         let (bs, i3) = pcs_betas(i2, rest, wrest, bits);
-        (store(ListNode.Cons([@gl_val(b0), @gl_val(b1)], bs)), i3),
+        (store(ListNode.Cons([@val_from_bytes(b0), @val_from_bytes(b1)], bs)), i3),
     }
   }
 
@@ -704,7 +943,7 @@ def pcs := ⟦
       _ => match circ_has_height(log_degrees, log_blowup, num_circuits, 0, h) {
         0 => build_buckets(log_degrees, log_blowup, num_circuits, h - 1),
         _ => store(ListNode.Cons(
-               Bucket.Mk(h, [1, 0], [0, 0]),
+               Bucket.Mk(h, [@val_one(), @val_zero()], [@val_zero(), @val_zero()]),
                build_buckets(log_degrees, log_blowup, num_circuits, h - 1))),
       },
     }
@@ -719,8 +958,8 @@ def pcs := ⟦
         let Bucket.Mk(h, ap, ro) = b;
         match eq_zero(h - lh) {
           1 =>
-            let (s, ap2) = ro_fold(p_x, p_z, alpha, [0, 0], ap);
-            let ro2 = @eg_add(ro, @eg_mul(q, s));
+            let (s, ap2) = ro_fold(p_x, p_z, alpha, [@val_zero(), @val_zero()], ap);
+            let ro2 = @ext_add(ro, @ext_mul(q, s));
             store(ListNode.Cons(Bucket.Mk(h, ap2, ro2), rest)),
           _ => store(ListNode.Cons(b, bucket_update(rest, lh, p_x, p_z, q, alpha))),
         },
@@ -735,7 +974,7 @@ def pcs := ⟦
       ListNode.Cons(b, rest) =>
         let Bucket.Mk(h, _ap, ro) = b;
         match eq_zero(h - log_blowup) {
-          1 => assert_eq!(@eg_eq(ro, [0, 0]), 1); 1,
+          1 => assert_eq!(@ext_eq(ro, [@val_zero(), @val_zero()]), 1); 1,
           _ => assert_blowup_zero(rest, log_blowup),
         },
     }
@@ -755,7 +994,7 @@ def pcs := ⟦
     -- (PointEvaluationCountMismatch); `ro_fold` walks them in lockstep.
     assert_eq!(eq_zero(list_length(p_x) - list_length(p_z)), 1);
     let x = @ro_x(list_drop(idxbits, log_gmax - lh), lh);
-    let q = @eg_inverse(@eg_sub(z, [x, 0]));
+    let q = @ext_inverse(@ext_sub(z, [x, @val_zero()]));
     bucket_update(buckets, lh, p_x, p_z, q, alpha)
   }
 
@@ -766,7 +1005,7 @@ def pcs := ⟦
       -> List‹Bucket› {
     let pz0 = list_lookup(mat, 0);
     let pz1 = list_lookup(mat, 1);
-    let zn = @eg_mul(zeta, [two_adic_gen(ldeg), 0]);
+    let zn = @ext_mul(zeta, [two_adic_gen(ldeg), @val_zero()]);
     let b1 = ri_apply(buckets, lh, idxbits, log_gmax, zeta, p_x, pz0, alpha);
     ri_apply(b1, lh, idxbits, log_gmax, zn, p_x, pz1, alpha)
   }
@@ -886,8 +1125,8 @@ def pcs := ⟦
   }
   -- Flatten two ext evals to the 4 base coords of the ExtensionMmcs leaf row.
   fn flatten2(e0: Ext, e1: Ext) -> List‹U64› {
-    store(ListNode.Cons(@gl_to_bytes(e0[0]), store(ListNode.Cons(@gl_to_bytes(e0[1]),
-      store(ListNode.Cons(@gl_to_bytes(e1[0]), store(ListNode.Cons(@gl_to_bytes(e1[1]), store(ListNode.Nil)))))))))
+    store(ListNode.Cons(@val_to_bytes(e0[0]), store(ListNode.Cons(@val_to_bytes(e0[1]),
+      store(ListNode.Cons(@val_to_bytes(e1[0]), store(ListNode.Cons(@val_to_bytes(e1[1]), store(ListNode.Nil)))))))))
   }
   -- Roll the next reduced opening into the folded eval when its height matches
   -- the new folded height: `folded += beta^(2^log_arity) · ro`  (log_arity = 1).
@@ -897,7 +1136,7 @@ def pcs := ⟦
       ListNode.Cons(b, rest) =>
         let Bucket.Mk(h, _ap, ro) = b;
         match eq_zero(h - log_folded) {
-          1 => (@eg_add(folded, @eg_mul(ext_exp_pow2(beta, 1), ro)), rest),
+          1 => (@ext_add(folded, @ext_mul(ext_exp_pow2(beta, 1), ro)), rest),
           _ => (folded, ro_rest),
         },
     }
@@ -975,7 +1214,7 @@ def pcs := ⟦
     assert_eq!(eq_zero(h0 - log_gmax), 1);
     let folded = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup);
     -- final check: with log_final_poly_len = 0, eval = final_poly[0]
-    assert_eq!(@eg_eq(list_lookup(final_poly, 0), folded), 1);
+    assert_eq!(@ext_eq(list_lookup(final_poly, 0), folded), 1);
     1
   }
 
@@ -1004,12 +1243,17 @@ def pcs := ⟦
   -- ── top-level FRI verification ────────────────────────────────────────────
   -- All FRI parameters (`log_blowup`, `num_queries`, `commit_pow_bits`,
   -- `query_pow_bits`) come from the digest-bound verifying key.
-  fn pcs_fri_verify(post_zeta_input: ByteStream, stage1: OpenedRound, stage2: OpenedRound,
-      q_opened: OpenedRound, prep_opt: PreprocessedOpt, opening: FriProof,
-      s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, prep_commit: MerkleCap,
+  -- Interface: verify the PCS opening proof — Rust `Pcs::verify` — over the
+  -- post-ζ transcript, the rounds (commitments + opened values per round),
+  -- and the PCS parameters from the vk.
+  fn pcs_verify(post_zeta_input: ByteStream, stage1: OpenedRound, stage2: OpenedRound,
+      q_opened: OpenedRound, prep_opt: PreprocessedOpt, opening: PcsProof,
+      s1c: Commitment, s2c: Commitment, qc: Commitment, prep_commit: Commitment,
       prep_indices: List‹OptIdx›, log_degrees: List‹U8›,
-      zeta: Ext, num_circuits: G, log_blowup: G, num_queries: G, commit_pow_bits: G,
-      query_pow_bits: G) -> G {
+      zeta: Ext, num_circuits: G, params: PcsParams) -> G {
+    let PcsParams.Mk(log_blowup, _cap_height, _log_final_poly_len,
+                     _max_log_arity, num_queries, commit_pow_bits,
+                     query_pow_bits) = params;
     let FriProof.Mk(commit_phase_commits, pw, query_proofs, final_poly, qpw) = opening;
     let num_rounds = list_length(commit_phase_commits);
     -- FRI shape: one PoW witness per round, num_queries query proofs, and (since
@@ -1025,7 +1269,7 @@ def pcs := ⟦
     let input = list_concat(post_zeta_input, obs);
     -- PCS batch-combination challenge α
     let (a0, a1, input, _oa) = ch_sample_ext(input, store(ListNode.Nil));
-    let alpha = [@gl_val(a0), @gl_val(a1)];
+    let alpha = [@val_from_bytes(a0), @val_from_bytes(a1)];
     -- per-round FRI fold challenges β (with commit-phase PoW), then observe
     -- final_poly + the log-arity schedule.
     let (betas, input) = pcs_betas(input, commit_phase_commits, pw, commit_pow_bits);
@@ -1046,6 +1290,30 @@ def pcs := ⟦
       num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds)
   }
 
+
+  -- ==========================================================================
+  -- Commitment serialization for the transcript (a `MerkleCap` = `Vec<Digest>`
+  -- observes all its digest bytes).
+  -- ==========================================================================
+  -- A digest = `[u64; 4]` = 32 bytes (each limb little-endian) onto `tail`.
+  fn digest_onto(d: Digest, tail: ByteStream) -> ByteStream {
+    b8_onto(d[0], b8_onto(d[1], b8_onto(d[2], b8_onto(d[3], tail))))
+  }
+
+  -- A commitment (`MerkleCap` = `Vec<Digest>`): all digest bytes, onto `tail`.
+  -- Interface: a commitment's transcript bytes (all digest bytes), onto `tail`.
+  fn commitment_onto(cap: Commitment, tail: ByteStream) -> ByteStream {
+    match load(cap) {
+      ListNode.Nil => tail,
+      ListNode.Cons(d, rest) => @digest_onto(load(d), commitment_onto(rest, tail)),
+    }
+  }
+
+  -- Append (observe) a commitment (`MerkleCap`) at the end of the buffer.
+  -- Interface: append (observe) a commitment at the end of the buffer.
+  fn snoc_commitment(input: ByteStream, cap: Commitment) -> ByteStream {
+    list_concat(input, commitment_onto(cap, store(ListNode.Nil)))
+  }
 ⟧
 
 end MultiStark
diff --git a/Ix/MultiStark/SystemDeserialize.lean b/Ix/MultiStark/SystemDeserialize.lean
index 05ff6c91..cf064a64 100644
--- a/Ix/MultiStark/SystemDeserialize.lean
+++ b/Ix/MultiStark/SystemDeserialize.lean
@@ -1,8 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.Core
-public import Ix.IxVM.ByteStream
-public import Ix.MultiStark.Deserialize
 
 /-!
 # Verifying-key deserializer (Aiur)
@@ -15,7 +12,7 @@ layout). The multi-stark constraint-IR migration replaced the per-circuit
 *symbolic* AIR (`SymbolicExpression` trees + `LookupAir`) with a *compiled*
 flat base-field node graph, so this reader parses that compiled form:
 
-* GLOBAL HEADER: 7 × u16 parameters + u16 circuit count.
+* GLOBAL HEADER: the PCS parameters (`read_pcs_params`; FRI: 7 × u16) + u16 circuit count.
 * PER-CIRCUIT RECORD (no framing prefix; nothing derivable is serialized —
   constraint_count, stage_2_width, num_publics, and lookup_prefix_len are
   all recomputed from the counts below):
@@ -34,7 +31,7 @@ flat base-field node graph, so this reader parses that compiled form:
     - u16 lookup_count, then the compiled lookups (u16 multiplicity NodeId,
       u16 arg count, u16 arg NodeIds) — these drive the verifier's direct
       logUp constraint evaluation (`Verifier.lean`).
-* TRAILER: preprocessed commit (`0` = None / `1` + MerkleCap) then one u16
+* TRAILER: preprocessed commit (`0` = None / `1` + the PCS's `Commitment`) then one u16
   per circuit for the preprocessed index (`0xFFFF` = None).
 
 The vk stream (IO channel 1) is fetched once as unconstrained advice, then
@@ -63,7 +60,7 @@ def systemDeserialize := ⟦
   -- not sub-trees: the graph is flat and topologically ordered (a node's
   -- children always have smaller indices).
   enum SysNode {
-    Const(G),            -- native Goldilocks constant (reduced on read)
+    Const(Val),   -- inner-field constant (reduced on read via `val_from_bytes`)
     Var(G, G, G),        -- source (0 Preprocessed, 1 Main, 2 Stage2), offset (0 current, 1 next), column index
     Public(G),           -- public-input coordinate index
     IsFirstRow,
@@ -84,13 +81,12 @@ def systemDeserialize := ⟦
   enum SysLookup { Mk(G, List‹G›) }
   enum SysCircuit { Mk(List‹SysNode›, G, List‹G›, G, List‹SysLookup›, G) }   -- nodes, node_count, zeros, max_constraint_degree, lookups, lookup_group_size
 
-  -- log_blowup, cap_height, log_final_poly_len, max_log_arity, num_queries,
-  -- commit_proof_of_work_bits, query_proof_of_work_bits — the commitment + FRI
-  -- parameters the config (and its challenger seed) was built from.
-  enum SysParams { Mk(G, G, G, G, G, G, G) }
+  -- The PCS/config parameters the vk opens with (`PcsParams`, read by the
+  -- PCS module's `read_pcs_params`): for FRI, log_blowup, cap_height,
+  -- log_final_poly_len, max_log_arity, num_queries, commit/query PoW bits.
 
   -- `Option`s as dedicated non-generic enums (unambiguous constructors).
-  enum OptCommit { NoCommit, SomeCommit(MerkleCap) }
+  enum OptCommit { NoCommit, SomeCommit(Commitment) }
   enum OptIdx { NoIdx, SomeIdx(G) }
 
   -- parameters, transcript limbs, circuits, preprocessed_commit,
@@ -99,7 +95,7 @@ def systemDeserialize := ⟦
   -- the challenger seed) followed by the system shape (`observe_shape`: the
   -- circuit count, then 6 metadata words per circuit) — kept as limbs because
   -- the Fiat-Shamir replay needs their little-endian bytes.
-  enum Sys { Mk(SysParams, List‹U64›, List‹SysCircuit›, OptCommit, List‹OptIdx›) }
+  enum Sys { Mk(PcsParams, List‹U64›, List‹SysCircuit›, OptCommit, List‹OptIdx›) }
 
   -- ==========================================================================
   -- Byte primitives over the already materialized vk stream. Each returns
@@ -158,28 +154,20 @@ def systemDeserialize := ⟦
     ([b0, b1, b2, b3, b4, b5, b6, b7], s7)
   }
 
-  -- A full (u64) Goldilocks constant, reduced into a native field value so it
-  -- can feed the composition arithmetic directly.
-  fn read_field(i: ByteStream) -> (G, ByteStream) {
+  -- A full (u64) Goldilocks constant, reduced into the merged module's
+  -- inner-field representation so it can feed the composition arithmetic
+  -- directly.
+  fn read_field(i: ByteStream) -> (Val, ByteStream) {
     let (u, j) = read_vk_u64(i);
-    (@gl_val(u), j)
+    (@val_from_bytes(u), j)
   }
 
-  fn read_vk_digest(i: ByteStream) -> (Digest, ByteStream) {
-    let (a, j0) = read_vk_u64(i);
-    let (b, j1) = read_vk_u64(j0);
-    let (c, j2) = read_vk_u64(j1);
-    let (d, j3) = read_vk_u64(j2);
-    ([a, b, c, d], j3)
-  }
-  fn read_vk_cap_n(i: ByteStream, n: G) -> (MerkleCap, ByteStream) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = @read_vk_digest(i);
-        let (rest, j2) = read_vk_cap_n(j, n - 1);
-        (store(ListNode.Cons(store(x), rest)), j2),
-    }
+  -- A small (u16) constant, ingested from its two raw bytes into the
+  -- inner-field representation (`ConstSmall` nodes).
+  fn read_small_field(s: ByteStream) -> (Val, ByteStream) {
+    let (b0, s0) = read_vk_u8(s);
+    let (b1, s1) = read_vk_u8(s0);
+    (@val_from_u16(b0, b1), s1)
   }
 
   -- ==========================================================================
@@ -193,7 +181,7 @@ def systemDeserialize := ⟦
   fn read_node(i: ByteStream) -> (SysNode, ByteStream) {
     let (tag, i1) = read_vk_tag(i);
     match tag {
-      0 => let (c, i2) = read_vk_u16(i1); (SysNode.Const(c), i2),
+      0 => let (c, i2) = read_small_field(i1); (SysNode.Const(c), i2),
       1 => let (c, i2) = read_field(i1); (SysNode.Const(c), i2),
       2 => let (idx, i2) = read_vk_tag(i1); (SysNode.Public(idx), i2),
       3 => (SysNode.IsFirstRow, i1),
@@ -236,7 +224,7 @@ def systemDeserialize := ⟦
         let (tag, i1) = read_vk_tag(i);
         match tag {
           0 =>
-            let (c, i2) = read_vk_u16(i1);
+            let (c, i2) = read_small_field(i1);
             let (rest, i3) = read_nodes_n(i2, n - 1);
             (store(ListNode.Cons(SysNode.Const(c), rest)), i3),
           1 =>
@@ -374,9 +362,9 @@ def systemDeserialize := ⟦
     -- `read_sys_circuits_n` (a let-bound match here tripped the inliner).
     let groups = lookup_groups_count(lcount, 0, k);
     let gslots = groups + eq_zero(groups);
-    let ccl = @gl_to_bytes(zcount + gslots + gslots);
-    let s2wl = @gl_to_bytes(gslots + gslots);
-    let kl = @gl_to_bytes(k);
+    let ccl = @count_to_bytes(zcount + gslots + gslots);
+    let s2wl = @count_to_bytes(gslots + gslots);
+    let kl = @count_to_bytes(k);
     (SysCircuit.Mk(nodes, ncount, zeros, md, lks, k),
      [ccl, mdl, phl, pwl, mwl, s2wl, kl], c10)
   }
@@ -406,8 +394,7 @@ def systemDeserialize := ⟦
     match tag {
       0 => (OptCommit.NoCommit, j),
       _ =>
-        let (n, j1) = read_vk_u16(j);
-        let (c, j2) = read_vk_cap_n(j1, n);
+        let (c, j2) = @read_vk_commitment(j);
         (OptCommit.SomeCommit(c), j2),
     }
   }
@@ -425,27 +412,10 @@ def systemDeserialize := ⟦
     }
   }
 
-  -- The 7 protocol parameters, both as field values (for the verifier logic)
-  -- and as u64 limbs (their LE bytes seed the challenger).
-  fn read_sys_params(i: ByteStream) -> (SysParams, List‹U64›, ByteStream) {
-    let (p0, l0, j0) = read_vk_u16_limb(i);
-    let (p1, l1, j1) = read_vk_u16_limb(j0);
-    let (p2, l2, j2) = read_vk_u16_limb(j1);
-    let (p3, l3, j3) = read_vk_u16_limb(j2);
-    let (p4, l4, j4) = read_vk_u16_limb(j3);
-    let (p5, l5, j5) = read_vk_u16_limb(j4);
-    let (p6, l6, j6) = read_vk_u16_limb(j5);
-    (SysParams.Mk(p0, p1, p2, p3, p4, p5, p6),
-     store(ListNode.Cons(l0, store(ListNode.Cons(l1, store(ListNode.Cons(l2,
-     store(ListNode.Cons(l3, store(ListNode.Cons(l4, store(ListNode.Cons(l5,
-     store(ListNode.Cons(l6, store(ListNode.Nil))))))))))))))),
-     j6)
-  }
-
   -- Full `System<AiurConfig>` parsed from the digest-bound byte stream.
   -- Returns the unconsumed suffix; the entrypoint asserts it is empty.
   fn read_system(i: ByteStream) -> (Sys, ByteStream) {
-    let (params, plimbs, j) = @read_sys_params(i);
+    let (params, plimbs, j) = @read_pcs_params(i);
     let (n, nlimb, j1) = read_vk_u16_limb(j);
     let (circuits, climbs, j2) = read_sys_circuits_n(j1, n);
     let (commit, j3) = read_opt_commit(j2);
diff --git a/Ix/MultiStark/Tests.lean b/Ix/MultiStark/Tests.lean
index 015c3077..aa8d2974 100644
--- a/Ix/MultiStark/Tests.lean
+++ b/Ix/MultiStark/Tests.lean
@@ -12,7 +12,7 @@ circuit to the compiled system, so keeping the tests out of
 `MultiStark.multiStark` keeps the production verifier's width free of
 test-only circuits.
 
-Cross-fragment references (e.g. `gl_val`, `mmcs_hash_row`, `fri_fold2`,
+Cross-fragment references (e.g. `val_from_bytes`, `mmcs_hash_row`, `fri_fold2`,
 `ch_sample_bits`) resolve after the merge — the merged toplevel has a flat
 namespace.
 -/
@@ -24,67 +24,67 @@ namespace MultiStark
 def tests := ⟦
   -- ==========================================================================
   -- Native Goldilocks arithmetic (vs `gl_ops_ref`; reference vectors kept as
-  -- their canonical LE bytes and folded with `gl_val`, which is injective on
+  -- their canonical LE bytes and folded with `val_from_bytes`, which is injective on
   -- canonical bytes).
   -- ==========================================================================
-  fn assert_g8(x: Goldilocks, e: Goldilocks) -> G {
+  fn assert_val(x: Val, e: Val) -> G {
     assert_eq!(x, e);
     1
   }
-  pub fn gl_addsub_test() -> G {
-    let a = @gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]); -- 0xFEDCBA9876543210
-    let b = @gl_val([240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]); -- 0x123456789ABCDEF0
-    assert_eq!(assert_g8(a + b, @gl_val([255u8, 16u8, 17u8, 17u8, 18u8, 17u8, 17u8, 17u8])), 1);
-    assert_eq!(assert_g8(a - b, @gl_val([32u8, 83u8, 151u8, 219u8, 31u8, 100u8, 168u8, 236u8])), 1);
-    assert_eq!(assert_g8(b - a, @gl_val([225u8, 172u8, 104u8, 36u8, 223u8, 155u8, 87u8, 19u8])), 1);
+  pub fn val_addsub_test() -> G {
+    let a = @val_from_bytes([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]); -- 0xFEDCBA9876543210
+    let b = @val_from_bytes([240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]); -- 0x123456789ABCDEF0
+    assert_eq!(assert_val(a + b, @val_from_bytes([255u8, 16u8, 17u8, 17u8, 18u8, 17u8, 17u8, 17u8])), 1);
+    assert_eq!(assert_val(a - b, @val_from_bytes([32u8, 83u8, 151u8, 219u8, 31u8, 100u8, 168u8, 236u8])), 1);
+    assert_eq!(assert_val(b - a, @val_from_bytes([225u8, 172u8, 104u8, 36u8, 223u8, 155u8, 87u8, 19u8])), 1);
     -- edge: (p-1) + 5 ≡ 4 ; 5 - (p-1) ≡ 6
-    let pm1 = @gl_val([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]); -- 0xFFFFFFFF00000000
-    let five = @gl_val([5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    assert_eq!(assert_g8(pm1 + five, @gl_val([4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])), 1);
-    assert_eq!(assert_g8(five - pm1, @gl_val([6u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])), 1);
+    let pm1 = @val_from_bytes([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]); -- 0xFFFFFFFF00000000
+    let five = @val_from_bytes([5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    assert_eq!(assert_val(pm1 + five, @val_from_bytes([4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])), 1);
+    assert_eq!(assert_val(five - pm1, @val_from_bytes([6u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])), 1);
     1
   }
 
-  fn assert_eg(x: ExtGoldilocks, e0: Goldilocks, e1: Goldilocks) -> G {
-    assert_eq!(assert_g8(x[0], e0), 1);
-    assert_eq!(assert_g8(x[1], e1), 1);
+  fn assert_ext(x: Ext, e0: Val, e1: Val) -> G {
+    assert_eq!(assert_val(x[0], e0), 1);
+    assert_eq!(assert_val(x[1], e1), 1);
     1
   }
-  pub fn gl_muldiv_test() -> G {
-    let a = @gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]); -- 0xFEDCBA9876543210
-    let b = @gl_val([240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]); -- 0x123456789ABCDEF0
-    assert_eq!(assert_g8(a * b, @gl_val([212u8, 186u8, 123u8, 108u8, 31u8, 253u8, 234u8, 250u8])), 1);
-    assert_eq!(assert_g8(@gl_inverse(a), @gl_val([97u8, 29u8, 109u8, 46u8, 183u8, 100u8, 8u8, 102u8])), 1);
-    assert_eq!(assert_g8(a * @gl_inverse(b), @gl_val([63u8, 59u8, 61u8, 54u8, 46u8, 255u8, 29u8, 186u8])), 1);
+  pub fn val_muldiv_test() -> G {
+    let a = @val_from_bytes([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]); -- 0xFEDCBA9876543210
+    let b = @val_from_bytes([240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]); -- 0x123456789ABCDEF0
+    assert_eq!(assert_val(a * b, @val_from_bytes([212u8, 186u8, 123u8, 108u8, 31u8, 253u8, 234u8, 250u8])), 1);
+    assert_eq!(assert_val(@val_inverse(a), @val_from_bytes([97u8, 29u8, 109u8, 46u8, 183u8, 100u8, 8u8, 102u8])), 1);
+    assert_eq!(assert_val(a * @val_inverse(b), @val_from_bytes([63u8, 59u8, 61u8, 54u8, 46u8, 255u8, 29u8, 186u8])), 1);
     -- edge: (p-1)·5 ≡ p-5
-    let pm1 = @gl_val([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]);
-    let five = @gl_val([5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    assert_eq!(assert_g8(pm1 * five, @gl_val([252u8, 255u8, 255u8, 255u8, 254u8, 255u8, 255u8, 255u8])), 1);
+    let pm1 = @val_from_bytes([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]);
+    let five = @val_from_bytes([5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    assert_eq!(assert_val(pm1 * five, @val_from_bytes([252u8, 255u8, 255u8, 255u8, 254u8, 255u8, 255u8, 255u8])), 1);
     -- a·a⁻¹ = 1 and b·b⁻¹ = 1
-    assert_eq!(assert_g8(a * @gl_inverse(a), 1), 1);
-    assert_eq!(assert_g8(b * @gl_inverse(b), 1), 1);
+    assert_eq!(assert_val(a * @val_inverse(a), 1), 1);
+    assert_eq!(assert_val(b * @val_inverse(b), 1), 1);
     1
   }
-  pub fn eg_ops_test() -> G {
+  pub fn ext_ops_test() -> G {
     -- e0 = (0xFEDCBA9876543210, 0x0123456789ABCDEF), e1 = (0x1111111122222222, 0x3333333344444444)
-    let e0 = [@gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]),
-              @gl_val([239u8, 205u8, 171u8, 137u8, 103u8, 69u8, 35u8, 1u8])];
-    let e1 = [@gl_val([34u8, 34u8, 34u8, 34u8, 17u8, 17u8, 17u8, 17u8]),
-              @gl_val([68u8, 68u8, 68u8, 68u8, 51u8, 51u8, 51u8, 51u8])];
-    assert_eq!(assert_eg(@eg_add(e0, e1),
-      @gl_val([49u8, 84u8, 118u8, 152u8, 170u8, 203u8, 237u8, 15u8]),
-      @gl_val([51u8, 18u8, 240u8, 205u8, 154u8, 120u8, 86u8, 52u8])), 1);
-    assert_eq!(assert_eg(@eg_mul(e0, e1),
-      @gl_val([10u8, 238u8, 162u8, 36u8, 224u8, 127u8, 182u8, 134u8]),
-      @gl_val([215u8, 234u8, 152u8, 224u8, 219u8, 254u8, 32u8, 67u8])), 1);
-    assert_eq!(assert_eg(@eg_inverse(e0),
-      @gl_val([221u8, 238u8, 29u8, 131u8, 179u8, 89u8, 214u8, 216u8]),
-      @gl_val([114u8, 99u8, 206u8, 108u8, 15u8, 88u8, 161u8, 246u8])), 1);
-    assert_eq!(assert_eg(@eg_div(e0, e1),
-      @gl_val([42u8, 59u8, 64u8, 77u8, 226u8, 214u8, 95u8, 63u8]),
-      @gl_val([200u8, 46u8, 148u8, 147u8, 124u8, 180u8, 248u8, 140u8])), 1);
+    let e0 = [@val_from_bytes([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]),
+              @val_from_bytes([239u8, 205u8, 171u8, 137u8, 103u8, 69u8, 35u8, 1u8])];
+    let e1 = [@val_from_bytes([34u8, 34u8, 34u8, 34u8, 17u8, 17u8, 17u8, 17u8]),
+              @val_from_bytes([68u8, 68u8, 68u8, 68u8, 51u8, 51u8, 51u8, 51u8])];
+    assert_eq!(assert_ext(@ext_add(e0, e1),
+      @val_from_bytes([49u8, 84u8, 118u8, 152u8, 170u8, 203u8, 237u8, 15u8]),
+      @val_from_bytes([51u8, 18u8, 240u8, 205u8, 154u8, 120u8, 86u8, 52u8])), 1);
+    assert_eq!(assert_ext(@ext_mul(e0, e1),
+      @val_from_bytes([10u8, 238u8, 162u8, 36u8, 224u8, 127u8, 182u8, 134u8]),
+      @val_from_bytes([215u8, 234u8, 152u8, 224u8, 219u8, 254u8, 32u8, 67u8])), 1);
+    assert_eq!(assert_ext(@ext_inverse(e0),
+      @val_from_bytes([221u8, 238u8, 29u8, 131u8, 179u8, 89u8, 214u8, 216u8]),
+      @val_from_bytes([114u8, 99u8, 206u8, 108u8, 15u8, 88u8, 161u8, 246u8])), 1);
+    assert_eq!(assert_ext(@ext_div(e0, e1),
+      @val_from_bytes([42u8, 59u8, 64u8, 77u8, 226u8, 214u8, 95u8, 63u8]),
+      @val_from_bytes([200u8, 46u8, 148u8, 147u8, 124u8, 180u8, 248u8, 140u8])), 1);
     -- e0 · e0⁻¹ = 1
-    assert_eq!(assert_eg(@eg_mul(e0, @eg_inverse(e0)), 1, 0), 1);
+    assert_eq!(assert_ext(@ext_mul(e0, @ext_inverse(e0)), 1, 0), 1);
     1
   }
 
@@ -145,12 +145,12 @@ def tests := ⟦
   pub fn fri_fold_test() -> G {
     let index_bits = store(ListNode.Cons(1, store(ListNode.Cons(0,
                        store(ListNode.Cons(1, store(ListNode.Nil)))))));
-    let e0 = [@gl_val([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]),
-              @gl_val([34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8])];
-    let e1 = [@gl_val([51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8]),
-              @gl_val([68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8])];
-    let beta = [@gl_val([85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8]),
-                @gl_val([102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8])];
+    let e0 = [@val_from_bytes([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]),
+              @val_from_bytes([34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8])];
+    let e1 = [@val_from_bytes([51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8]),
+              @val_from_bytes([68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8])];
+    let beta = [@val_from_bytes([85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8]),
+                @val_from_bytes([102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8])];
     let folded = fri_fold2(index_bits, 3, beta, e0, e1);
     assert_eq!(folded[0], 9349172584842537206);
     assert_eq!(folded[1], 984486879173118962);
@@ -164,23 +164,23 @@ def tests := ⟦
                        store(ListNode.Cons(1, store(ListNode.Nil)))))));
     let x = ro_x(index_bits, 3);
     assert_eq!(x, 117440512);
-    let z = [@gl_val([154u8, 120u8, 86u8, 52u8, 18u8, 0u8, 0u8, 0u8]),
-             @gl_val([1u8, 239u8, 205u8, 171u8, 0u8, 0u8, 0u8, 0u8])];
-    let alpha = [@gl_val([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]),
-                 @gl_val([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
+    let z = [@val_from_bytes([154u8, 120u8, 86u8, 52u8, 18u8, 0u8, 0u8, 0u8]),
+             @val_from_bytes([1u8, 239u8, 205u8, 171u8, 0u8, 0u8, 0u8, 0u8])];
+    let alpha = [@val_from_bytes([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]),
+                 @val_from_bytes([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
     let px0 = [11u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
     let px1 = [22u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
     let px2 = [33u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
     let p_x = store(ListNode.Cons(px0, store(ListNode.Cons(px1,
                 store(ListNode.Cons(px2, store(ListNode.Nil)))))));
-    let pz0 = [@gl_val([100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
-    let pz1 = [@gl_val([200u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
-    let pz2 = [@gl_val([44u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
+    let pz0 = [@val_from_bytes([100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @val_from_bytes([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
+    let pz1 = [@val_from_bytes([200u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @val_from_bytes([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
+    let pz2 = [@val_from_bytes([44u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @val_from_bytes([3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
     let p_z = store(ListNode.Cons(pz0, store(ListNode.Cons(pz1,
                 store(ListNode.Cons(pz2, store(ListNode.Nil)))))));
-    let q = @eg_inverse(@eg_sub(z, [x, 0]));
+    let q = @ext_inverse(@ext_sub(z, [x, 0]));
     let (s, _ap) = ro_fold(p_x, p_z, alpha, [0, 0], [1, 0]);
-    let ro = @eg_mul(q, s);
+    let ro = @ext_mul(q, s);
     assert_eq!(ro[0], 7130765474285082575);
     assert_eq!(ro[1], 12254464995725315436);
     1
diff --git a/Ix/MultiStark/Transcript/Blake3.lean b/Ix/MultiStark/Transcript/Blake3.lean
new file mode 100644
index 00000000..eba02416
--- /dev/null
+++ b/Ix/MultiStark/Transcript/Blake3.lean
@@ -0,0 +1,226 @@
+module
+public import Ix.Aiur.Meta
+
+/-!
+# Transcript interface: the Blake3 byte challenger
+
+The Fiat-Shamir transcript both multi-stark configs use
+(`SerializingChallenger64<Val, HashChallenger<u8, Blake3, 32>>` in Rust;
+`Transcript` in pcs-traits), threaded as a pair `(input, output)` of byte
+lists. This is the one transcript implementation (blake3 is fixed by
+design); it lives apart from the verifier core so the core refers only to
+the transcript's NAMES — `ch_sample8`/`ch_sample_field`/`ch_sample_ext`/
+`ch_sample_bits` (draws, with rejection sampling of field elements),
+`ch_observe_val`/`snoc_b8` (appends), the prepend-built segments
+(`b8_onto`, `limbs_onto`, `log_degrees_onto`, `accs_onto`), `rev_onto`,
+and `seed_tag_onto` (the domain-separation tag). Commitment serialization
+belongs to the PCS (`commitment_onto` in its module): the transcript only
+knows bytes. Field elements cross through the field interface
+(`val_from_bytes` on draws, `val_to_bytes` on observes).
+-/
+
+public section
+
+namespace MultiStark
+
+def transcriptBlake3 := ⟦
+  -- ==========================================================================
+  -- Fiat-Shamir challenger: `SerializingChallenger64<Val, HashChallenger<u8,
+  -- Blake3, 32>>`. The inner byte challenger keeps an `input` buffer; a
+  -- `sample` with empty `output` flushes (`input := output := blake3(input)`)
+  -- and pops bytes from the END of the hash output. The outer layer serializes
+  -- field elements as 8 little-endian bytes and samples field elements as
+  -- 8-byte little-endian u64s.
+  --
+  -- The challenger is threaded as a pair `(input, output)` of byte lists, where
+  -- `output` is held in pop order (front = next byte = hash byte 31, 30, …).
+  -- ==========================================================================
+
+  -- Cons 8 bytes (LSB-first) of `b` onto `tail` (one byte list segment).
+  fn b8_onto(b: [U8; 8], tail: ByteStream) -> ByteStream {
+    store(ListNode.Cons(b[0], store(ListNode.Cons(b[1], store(ListNode.Cons(b[2],
+    store(ListNode.Cons(b[3], store(ListNode.Cons(b[4], store(ListNode.Cons(b[5],
+    store(ListNode.Cons(b[6], store(ListNode.Cons(b[7], tail))))))))))))))))
+  }
+
+
+
+  -- Observe `log_degrees`: each is a `Val::from_u8`, i.e. 8 LE bytes `[ld,0,…]`.
+  fn log_degrees_onto(lds: List‹U8›, tail: ByteStream) -> ByteStream {
+    match load(lds) {
+      ListNode.Nil => tail,
+      ListNode.Cons(ld, rest) =>
+        b8_onto([ld, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], log_degrees_onto(rest, tail)),
+    }
+  }
+
+  -- Reverse `l` onto `acc` (used to put a hash output into pop order).
+  fn rev_onto(l: ByteStream, acc: ByteStream) -> ByteStream {
+    match load(l) {
+      ListNode.Nil => acc,
+      ListNode.Cons(b, rest) => rev_onto(rest, store(ListNode.Cons(b, acc))),
+    }
+  }
+
+  -- Sample 8 bytes = `sample_array()` (for one base-field element, LE).
+  -- The output buffer always holds a multiple of 8 bytes at a draw boundary
+  -- (a flush refills 32, every draw takes 8, an observe clears to Nil), so
+  -- the empty check happens at most once per draw: flush, then pop 8. The
+  -- two arms' pops share columns (branch aux/lookups combine by max), which
+  -- is what makes this strictly narrower than a per-byte sampler circuit.
+  fn ch_sample8(input: ByteStream, output: ByteStream) -> ([U8; 8], ByteStream, ByteStream) {
+    match load(output) {
+      ListNode.Nil =>
+        -- `HashChallenger<u8, Blake3, 32>` flush: hash the `input` buffer with
+        -- blake3; `b3_flatten_onto` (Pcs.lean) gives the 32 output bytes, popped
+        -- from the END (rev), with the `input := output := hash` update.
+        let h = @blake3(input);
+        let fwd = @b3_flatten_onto(h, store(ListNode.Nil));
+        let rev = rev_onto(fwd, store(ListNode.Nil));
+        let &ListNode.Cons(b0, r1) = rev;
+        let &ListNode.Cons(b1, r2) = r1;
+        let &ListNode.Cons(b2, r3) = r2;
+        let &ListNode.Cons(b3, r4) = r3;
+        let &ListNode.Cons(b4, r5) = r4;
+        let &ListNode.Cons(b5, r6) = r5;
+        let &ListNode.Cons(b6, r7) = r6;
+        let &ListNode.Cons(b7, r8) = r7;
+        ([b0, b1, b2, b3, b4, b5, b6, b7], fwd, r8),
+      ListNode.Cons(b0, r1) =>
+        let &ListNode.Cons(b1, r2) = r1;
+        let &ListNode.Cons(b2, r3) = r2;
+        let &ListNode.Cons(b3, r4) = r3;
+        let &ListNode.Cons(b4, r5) = r4;
+        let &ListNode.Cons(b5, r6) = r5;
+        let &ListNode.Cons(b6, r7) = r6;
+        let &ListNode.Cons(b7, r8) = r7;
+        ([b0, b1, b2, b3, b4, b5, b6, b7], input, r8),
+    }
+  }
+
+  -- Sample one base-field element with REJECTION SAMPLING, mirroring
+  -- `SerializingChallenger64::sample`'s inner loop: draw 8 bytes as a LE u64
+  -- (the `log2_ceil(p) = 64` mask is a no-op for Goldilocks); if the raw value
+  -- is ≥ p (probability ≈ 2⁻³²), DISCARD it and draw the next 8 bytes — a
+  -- rejected draw consumes challenger bytes, shifting every later sample,
+  -- exactly as in the reference. `bytes_lt_modulus` decides `raw < p`; the accepted
+  -- limb is canonical (< p) by construction.
+  fn ch_sample_field(input: ByteStream, output: ByteStream) -> ([U8; 8], ByteStream, ByteStream) {
+    let (raw, i1, o1) = ch_sample8(input, output);
+    match @bytes_lt_modulus(raw) {
+      1 => (raw, i1, o1),
+      _ => ch_sample_field(i1, o1),
+    }
+  }
+
+  -- Sample a degree-2 extension element: two base samples (`from_basis_*`),
+  -- each rejection-sampled, returning their 8-byte LE limbs (canonical, but
+  -- also re-observable as raw bytes) and the threaded challenger.
+  fn ch_sample_ext(input: ByteStream, output: ByteStream) -> ([U8; 8], [U8; 8], ByteStream, ByteStream) {
+    let (c0, i0, o0) = ch_sample_field(input, output);
+    let (c1, i1, o1) = ch_sample_field(i0, o0);
+    (c0, c1, i1, o1)
+  }
+
+  -- Prepend the 8 elements of `d` onto `tail` (generic list helper).
+  fn cons8(d: [G; 8], tail: List‹G›) -> List‹G› {
+    store(ListNode.Cons(d[0], store(ListNode.Cons(d[1], store(ListNode.Cons(d[2],
+    store(ListNode.Cons(d[3], store(ListNode.Cons(d[4], store(ListNode.Cons(d[5],
+    store(ListNode.Cons(d[6], store(ListNode.Cons(d[7], tail))))))))))))))))
+  }
+
+  -- `sample_bits(n)` (FRI query index). `SerializingChallenger64::sample_bits`
+  -- reads one 8-byte sample as a little-endian u64 and masks the low `n` bits.
+  -- We return the low `n` bits as a list (LSB first = the leaf→root Merkle/FRI
+  -- path). Only the low 4 bytes are decomposed: 32 bits bound every
+  -- log-height (Goldilocks two-adicity is 32), and `take_bits` aborts on the
+  -- Nil match if `n` ever exceeded 32 — exactly as it did at 64 with the old
+  -- full decomposition. The full 8 bytes are still drawn (Fiat-Shamir
+  -- alignment with the reference challenger).
+  fn take_bits(bits: List‹G›, n: G) -> List‹G› {
+    match n {
+      0 => store(ListNode.Nil),
+      _ =>
+        let &ListNode.Cons(b, rest) = bits;
+        store(ListNode.Cons(b, take_bits(rest, n - 1))),
+    }
+  }
+  fn ch_sample_bits(input: ByteStream, output: ByteStream, n: G)
+      -> (List‹G›, ByteStream, ByteStream) {
+    let (bytes, i1, o1) = ch_sample8(input, output);
+    let bits =
+      cons8(u8_bit_decomposition(bytes[0]),
+      cons8(u8_bit_decomposition(bytes[1]),
+      cons8(u8_bit_decomposition(bytes[2]),
+      cons8(u8_bit_decomposition(bytes[3]), store(ListNode.Nil)))));
+    (take_bits(bits, n), i1, o1)
+  }
+
+  -- Append (observe) 8 little-endian bytes of `b` at the END of the challenger
+  -- input buffer. The transcript is held front-to-back (front = first observed =
+  -- first hashed, matching `blake3`'s absorption order), so an observation
+  -- appends — `b8_onto` PREPENDS, hence the `list_concat`.
+  fn snoc_b8(input: ByteStream, b: [U8; 8]) -> ByteStream {
+    list_concat(input, b8_onto(b, store(ListNode.Nil)))
+  }
+  -- The intermediate accumulators as a prepend-built stream, in order — each
+  -- an `observe_algebra_element`: two canonical 8-LE-byte limbs. (`read_ext`
+  -- reduced the limbs mod p, matching `as_canonical_u64` serialization.)
+  -- Prepend-composed so observing all of them is one `list_concat`, not a
+  -- per-element re-walk of the input buffer.
+  fn accs_onto(accs: List‹Ext›, tail: ByteStream) -> ByteStream {
+    match load(accs) {
+      ListNode.Nil => tail,
+      ListNode.Cons(e, rest) => b8_onto(@val_to_bytes(e[0]), b8_onto(@val_to_bytes(e[1]), accs_onto(rest, tail))),
+    }
+  }
+
+  -- ==========================================================================
+  -- PCS challenger continuation (Phase 4): the post-ζ transcript that
+  -- `two_adic_pcs::verify` + `verify_fri` replay. Unlike `fiat_shamir` — where
+  -- every sample is followed by an observe (so each sample re-flushes from an
+  -- empty `output`) — the PCS phase has *consecutive* samples with no observe
+  -- between (the PCS batch challenge α, then immediately the FRI batch challenge
+  -- α). So both challenger buffers must be threaded: `output` carries the
+  -- leftover hash bytes from one sample into the next instead of re-flushing.
+  -- ==========================================================================
+
+  -- Observe one `Val` (8 LE bytes): append to `input`, CLEAR `output` (any
+  -- leftover sampled bytes are discarded), per `HashChallenger::observe`.
+  fn ch_observe_val(input: ByteStream, v: U64) -> (ByteStream, ByteStream) {
+    (snoc_b8(input, v), store(ListNode.Nil))
+  }
+
+  -- Sample a degree-2 extension element, threading BOTH challenger buffers so a
+  -- following consecutive sample continues from the same hash `output` stream
+  -- (no re-flush). Limbs are rejection-sampled (`ch_sample_field`), so they are
+  -- canonical; the `gl_reduce` is a no-op kept for type/intent clarity.
+  fn pcs_sample_ext(input: ByteStream, output: ByteStream)
+      -> (Ext, ByteStream, ByteStream) {
+    let (c0, c1, i1, o1) = ch_sample_ext(input, output);
+    ([@val_from_bytes(c0), @val_from_bytes(c1)], i1, o1)
+  }
+
+  -- `b"multi-stark/v0"` — the domain-separation tag the challenger seed
+  -- starts with (`GoldilocksBlake3Config::new`).
+  fn seed_tag_onto(tail: ByteStream) -> ByteStream {
+    store(ListNode.Cons(109u8, store(ListNode.Cons(117u8, store(ListNode.Cons(108u8,
+    store(ListNode.Cons(116u8, store(ListNode.Cons(105u8, store(ListNode.Cons(45u8,
+    store(ListNode.Cons(115u8, store(ListNode.Cons(116u8, store(ListNode.Cons(97u8,
+    store(ListNode.Cons(114u8, store(ListNode.Cons(107u8, store(ListNode.Cons(47u8,
+    store(ListNode.Cons(118u8, store(ListNode.Cons(48u8,
+    tail))))))))))))))))))))))))))))
+  }
+  -- Raw u64 wire words (protocol parameters + system shape), each as its 8 LE
+  -- bytes, in order.
+  fn limbs_onto(ls: List‹U64›, tail: ByteStream) -> ByteStream {
+    match load(ls) {
+      ListNode.Nil => tail,
+      ListNode.Cons(l, rest) => b8_onto(l, limbs_onto(rest, tail)),
+    }
+  }
+⟧
+
+end MultiStark
+
+end
diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean
index b11b6a79..dc7c6c3b 100644
--- a/Ix/MultiStark/Verifier.lean
+++ b/Ix/MultiStark/Verifier.lean
@@ -1,11 +1,5 @@
 module
 public import Ix.Aiur.Meta
-public import Ix.IxVM.Core
-public import Ix.IxVM.ByteStream
-public import Ix.MultiStark.Deserialize
-public import Ix.MultiStark.Keccak
-public import Ix.MultiStark.Pcs
-public import Ix.MultiStark.SystemDeserialize
 
 /-!
 # Multi-STARK verifier (Aiur)
@@ -50,7 +44,7 @@ The Rust verifier runs these steps:
   test runner, `Tests/MultiStark.lean`): the verifier accepts the honest proof
   and rejects a tampered claim.
 
-* Step 4: the PCS/FRI opening proof (`pcs_fri_verify`, `Ix/MultiStark/Pcs.lean`)
+* Step 4: the PCS opening proof (`pcs_verify` — the merged PCS module, e.g. `Ix/MultiStark/Pcs/Fri.lean`)
   — Merkle `verify_batch`, the challenger continuation, the FRI fold chain, and
   the final-polynomial check.
 
@@ -68,7 +62,7 @@ def verifier := ⟦
   -- An extension element `[c0, c1]` (`= c0 + c1·X`) is zero iff both Goldilocks
   -- coefficients are zero. (`read_ext` already reduced the limbs mod p.)
   fn ext_is_zero(e: Ext) -> G {
-    eq_zero(e[0]) * eq_zero(e[1])
+    @val_is_zero(e[0]) * @val_is_zero(e[1])
   }
 
   -- 1 iff the LAST element of the accumulator list is the zero extension
@@ -85,222 +79,11 @@ def verifier := ⟦
     }
   }
 
-  -- ==========================================================================
-  -- Fiat-Shamir challenger: `SerializingChallenger64<Val, HashChallenger<u8,
-  -- Blake3, 32>>`. The inner byte challenger keeps an `input` buffer; a
-  -- `sample` with empty `output` flushes (`input := output := blake3(input)`)
-  -- and pops bytes from the END of the hash output. The outer layer serializes
-  -- field elements as 8 little-endian bytes and samples field elements as
-  -- 8-byte little-endian u64s.
-  --
-  -- The challenger is threaded as a pair `(input, output)` of byte lists, where
-  -- `output` is held in pop order (front = next byte = hash byte 31, 30, …).
-  -- ==========================================================================
-
-  -- Cons 8 bytes (LSB-first) of `b` onto `tail` (one byte list segment).
-  fn b8_onto(b: [U8; 8], tail: ByteStream) -> ByteStream {
-    store(ListNode.Cons(b[0], store(ListNode.Cons(b[1], store(ListNode.Cons(b[2],
-    store(ListNode.Cons(b[3], store(ListNode.Cons(b[4], store(ListNode.Cons(b[5],
-    store(ListNode.Cons(b[6], store(ListNode.Cons(b[7], tail))))))))))))))))
-  }
-
-  -- A digest = `[u64; 4]` = 32 bytes (each limb little-endian) onto `tail`.
-  fn digest_onto(d: Digest, tail: ByteStream) -> ByteStream {
-    b8_onto(d[0], b8_onto(d[1], b8_onto(d[2], b8_onto(d[3], tail))))
-  }
-
-  -- A commitment (`MerkleCap` = `Vec<Digest>`): all digest bytes, onto `tail`.
-  fn cap_onto(cap: MerkleCap, tail: ByteStream) -> ByteStream {
-    match load(cap) {
-      ListNode.Nil => tail,
-      ListNode.Cons(d, rest) => @digest_onto(load(d), cap_onto(rest, tail)),
-    }
-  }
-
-  -- Observe `log_degrees`: each is a `Val::from_u8`, i.e. 8 LE bytes `[ld,0,…]`.
-  fn log_degrees_onto(lds: List‹U8›, tail: ByteStream) -> ByteStream {
-    match load(lds) {
-      ListNode.Nil => tail,
-      ListNode.Cons(ld, rest) =>
-        b8_onto([ld, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], log_degrees_onto(rest, tail)),
-    }
-  }
-
-  -- Reverse `l` onto `acc` (used to put a hash output into pop order).
-  fn rev_onto(l: ByteStream, acc: ByteStream) -> ByteStream {
-    match load(l) {
-      ListNode.Nil => acc,
-      ListNode.Cons(b, rest) => rev_onto(rest, store(ListNode.Cons(b, acc))),
-    }
-  }
-
-  -- Sample 8 bytes = `sample_array()` (for one base-field element, LE).
-  -- The output buffer always holds a multiple of 8 bytes at a draw boundary
-  -- (a flush refills 32, every draw takes 8, an observe clears to Nil), so
-  -- the empty check happens at most once per draw: flush, then pop 8. The
-  -- two arms' pops share columns (branch aux/lookups combine by max), which
-  -- is what makes this strictly narrower than a per-byte sampler circuit.
-  fn ch_sample8(input: ByteStream, output: ByteStream) -> ([U8; 8], ByteStream, ByteStream) {
-    match load(output) {
-      ListNode.Nil =>
-        -- `HashChallenger<u8, Blake3, 32>` flush: hash the `input` buffer with
-        -- blake3; `b3_flatten_onto` (Pcs.lean) gives the 32 output bytes, popped
-        -- from the END (rev), with the `input := output := hash` update.
-        let h = @blake3(input);
-        let fwd = @b3_flatten_onto(h, store(ListNode.Nil));
-        let rev = rev_onto(fwd, store(ListNode.Nil));
-        let &ListNode.Cons(b0, r1) = rev;
-        let &ListNode.Cons(b1, r2) = r1;
-        let &ListNode.Cons(b2, r3) = r2;
-        let &ListNode.Cons(b3, r4) = r3;
-        let &ListNode.Cons(b4, r5) = r4;
-        let &ListNode.Cons(b5, r6) = r5;
-        let &ListNode.Cons(b6, r7) = r6;
-        let &ListNode.Cons(b7, r8) = r7;
-        ([b0, b1, b2, b3, b4, b5, b6, b7], fwd, r8),
-      ListNode.Cons(b0, r1) =>
-        let &ListNode.Cons(b1, r2) = r1;
-        let &ListNode.Cons(b2, r3) = r2;
-        let &ListNode.Cons(b3, r4) = r3;
-        let &ListNode.Cons(b4, r5) = r4;
-        let &ListNode.Cons(b5, r6) = r5;
-        let &ListNode.Cons(b6, r7) = r6;
-        let &ListNode.Cons(b7, r8) = r7;
-        ([b0, b1, b2, b3, b4, b5, b6, b7], input, r8),
-    }
-  }
-
-  -- Sample one base-field element with REJECTION SAMPLING, mirroring
-  -- `SerializingChallenger64::sample`'s inner loop: draw 8 bytes as a LE u64
-  -- (the `log2_ceil(p) = 64` mask is a no-op for Goldilocks); if the raw value
-  -- is ≥ p (probability ≈ 2⁻³²), DISCARD it and draw the next 8 bytes — a
-  -- rejected draw consumes challenger bytes, shifting every later sample,
-  -- exactly as in the reference. `gl_lt_p` decides `raw < p`; the accepted
-  -- limb is canonical (< p) by construction.
-  fn ch_sample_field(input: ByteStream, output: ByteStream) -> ([U8; 8], ByteStream, ByteStream) {
-    let (raw, i1, o1) = ch_sample8(input, output);
-    match @gl_lt_p(raw) {
-      1 => (raw, i1, o1),
-      _ => ch_sample_field(i1, o1),
-    }
-  }
-
-  -- Sample a degree-2 extension element: two base samples (`from_basis_*`),
-  -- each rejection-sampled, returning their 8-byte LE limbs (canonical, but
-  -- also re-observable as raw bytes) and the threaded challenger.
-  fn ch_sample_ext(input: ByteStream, output: ByteStream) -> ([U8; 8], [U8; 8], ByteStream, ByteStream) {
-    let (c0, i0, o0) = ch_sample_field(input, output);
-    let (c1, i1, o1) = ch_sample_field(i0, o0);
-    (c0, c1, i1, o1)
-  }
-
-  -- Prepend the 8 elements of `d` onto `tail` (generic list helper).
-  fn cons8(d: [G; 8], tail: List‹G›) -> List‹G› {
-    store(ListNode.Cons(d[0], store(ListNode.Cons(d[1], store(ListNode.Cons(d[2],
-    store(ListNode.Cons(d[3], store(ListNode.Cons(d[4], store(ListNode.Cons(d[5],
-    store(ListNode.Cons(d[6], store(ListNode.Cons(d[7], tail))))))))))))))))
-  }
-
-  -- `sample_bits(n)` (FRI query index). `SerializingChallenger64::sample_bits`
-  -- reads one 8-byte sample as a little-endian u64 and masks the low `n` bits.
-  -- We return the low `n` bits as a list (LSB first = the leaf→root Merkle/FRI
-  -- path). Only the low 4 bytes are decomposed: 32 bits bound every
-  -- log-height (Goldilocks two-adicity is 32), and `take_bits` aborts on the
-  -- Nil match if `n` ever exceeded 32 — exactly as it did at 64 with the old
-  -- full decomposition. The full 8 bytes are still drawn (Fiat-Shamir
-  -- alignment with the reference challenger).
-  fn take_bits(bits: List‹G›, n: G) -> List‹G› {
-    match n {
-      0 => store(ListNode.Nil),
-      _ =>
-        let &ListNode.Cons(b, rest) = bits;
-        store(ListNode.Cons(b, take_bits(rest, n - 1))),
-    }
-  }
-  fn ch_sample_bits(input: ByteStream, output: ByteStream, n: G)
-      -> (List‹G›, ByteStream, ByteStream) {
-    let (bytes, i1, o1) = ch_sample8(input, output);
-    let bits =
-      cons8(u8_bit_decomposition(bytes[0]),
-      cons8(u8_bit_decomposition(bytes[1]),
-      cons8(u8_bit_decomposition(bytes[2]),
-      cons8(u8_bit_decomposition(bytes[3]), store(ListNode.Nil)))));
-    (take_bits(bits, n), i1, o1)
-  }
-
-  -- Append (observe) 8 little-endian bytes of `b` at the END of the challenger
-  -- input buffer. The transcript is held front-to-back (front = first observed =
-  -- first hashed, matching `blake3`'s absorption order), so an observation
-  -- appends — `b8_onto` PREPENDS, hence the `list_concat`.
-  fn snoc_b8(input: ByteStream, b: [U8; 8]) -> ByteStream {
-    list_concat(input, b8_onto(b, store(ListNode.Nil)))
-  }
-  -- Append (observe) a commitment (`MerkleCap`) at the end of the buffer.
-  fn snoc_cap(input: ByteStream, cap: MerkleCap) -> ByteStream {
-    list_concat(input, cap_onto(cap, store(ListNode.Nil)))
-  }
-  -- The intermediate accumulators as a prepend-built stream, in order — each
-  -- an `observe_algebra_element`: two canonical 8-LE-byte limbs. (`read_ext`
-  -- reduced the limbs mod p, matching `as_canonical_u64` serialization.)
-  -- Prepend-composed so observing all of them is one `list_concat`, not a
-  -- per-element re-walk of the input buffer.
-  fn accs_onto(accs: List‹Ext›, tail: ByteStream) -> ByteStream {
-    match load(accs) {
-      ListNode.Nil => tail,
-      ListNode.Cons(e, rest) => b8_onto(@gl_to_bytes(e[0]), b8_onto(@gl_to_bytes(e[1]), accs_onto(rest, tail))),
-    }
-  }
-
-  -- ==========================================================================
-  -- PCS challenger continuation (Phase 4): the post-ζ transcript that
-  -- `two_adic_pcs::verify` + `verify_fri` replay. Unlike `fiat_shamir` — where
-  -- every sample is followed by an observe (so each sample re-flushes from an
-  -- empty `output`) — the PCS phase has *consecutive* samples with no observe
-  -- between (the PCS batch challenge α, then immediately the FRI batch challenge
-  -- α). So both challenger buffers must be threaded: `output` carries the
-  -- leftover hash bytes from one sample into the next instead of re-flushing.
-  -- ==========================================================================
-
-  -- Observe one `Val` (8 LE bytes): append to `input`, CLEAR `output` (any
-  -- leftover sampled bytes are discarded), per `HashChallenger::observe`.
-  fn ch_observe_val(input: ByteStream, v: U64) -> (ByteStream, ByteStream) {
-    (snoc_b8(input, v), store(ListNode.Nil))
-  }
-
-  -- Sample a degree-2 extension element, threading BOTH challenger buffers so a
-  -- following consecutive sample continues from the same hash `output` stream
-  -- (no re-flush). Limbs are rejection-sampled (`ch_sample_field`), so they are
-  -- canonical; the `gl_reduce` is a no-op kept for type/intent clarity.
-  fn pcs_sample_ext(input: ByteStream, output: ByteStream)
-      -> (Ext, ByteStream, ByteStream) {
-    let (c0, c1, i1, o1) = ch_sample_ext(input, output);
-    ([@gl_val(c0), @gl_val(c1)], i1, o1)
-  }
-
-  -- `b"multi-stark/v0"` — the domain-separation tag the challenger seed
-  -- starts with (`GoldilocksBlake3Config::new`).
-  fn seed_tag_onto(tail: ByteStream) -> ByteStream {
-    store(ListNode.Cons(109u8, store(ListNode.Cons(117u8, store(ListNode.Cons(108u8,
-    store(ListNode.Cons(116u8, store(ListNode.Cons(105u8, store(ListNode.Cons(45u8,
-    store(ListNode.Cons(115u8, store(ListNode.Cons(116u8, store(ListNode.Cons(97u8,
-    store(ListNode.Cons(114u8, store(ListNode.Cons(107u8, store(ListNode.Cons(47u8,
-    store(ListNode.Cons(118u8, store(ListNode.Cons(48u8,
-    tail))))))))))))))))))))))))))))
-  }
-  -- Raw u64 wire words (protocol parameters + system shape), each as its 8 LE
-  -- bytes, in order.
-  fn limbs_onto(ls: List‹U64›, tail: ByteStream) -> ByteStream {
-    match load(ls) {
-      ListNode.Nil => tail,
-      ListNode.Cons(l, rest) => b8_onto(l, limbs_onto(rest, tail)),
-    }
-  }
-
-  -- The preprocessed commitment cap from the verifying key, or an empty cap
-  -- (observes nothing) when there is none.
-  fn opt_commit_cap(commit: OptCommit) -> MerkleCap {
+  -- The preprocessed commitment from the verifying key, or the PCS's empty
+  -- commitment (observes nothing) when there is none.
+  fn opt_commitment(commit: OptCommit) -> Commitment {
     match commit {
-      OptCommit.NoCommit => store(ListNode.Nil),
+      OptCommit.NoCommit => @pcs_empty_commitment(),
       OptCommit.SomeCommit(c) => c,
     }
   }
@@ -334,8 +117,8 @@ def verifier := ⟦
     }
   }
 
-  fn fiat_shamir(tlimbs: List‹U64›, active: List‹G›, prep: MerkleCap, s1: MerkleCap, s2: MerkleCap,
-      q: MerkleCap, lds: List‹U8›, cbytes: ByteStream, accs: List‹Ext›)
+  fn fiat_shamir(tlimbs: List‹U64›, active: List‹G›, prep: Commitment, s1: Commitment,
+      s2: Commitment, q: Commitment, lds: List‹U8›, cbytes: ByteStream, accs: List‹Ext›)
       -> (Ext, Ext, Ext, Ext, ByteStream) {
     -- Initial transcript, front-to-back: seed tag, parameter + shape words
     -- (`tlimbs`, from the verifying key), the activation bitmap, prep,
@@ -346,8 +129,8 @@ def verifier := ⟦
     -- encoding `verify_multiple_claims` observes, and the entrypoint
     -- asserts the stream fully consumed — so no re-serialization walk.
     let input = log_degrees_onto(lds, cbytes);
-    let input = cap_onto(s1, input);
-    let input = cap_onto(prep, input);
+    let input = commitment_onto(s1, input);
+    let input = commitment_onto(prep, input);
     let input = active_onto(active, input);
     let input = limbs_onto(tlimbs, input);
     let input = @seed_tag_onto(input);
@@ -359,87 +142,23 @@ def verifier := ⟦
     let (f0, f1, input, _of) = ch_sample_ext(input, store(ListNode.Nil));
     let input = list_concat(input, b8_onto(f0, b8_onto(f1, store(ListNode.Nil))));
     -- observe stage_2 commitment
-    let input = snoc_cap(input, s2);
+    let input = snoc_commitment(input, s2);
     -- observe the intermediate accumulators (public values entering the
     -- constraints; α and ζ must depend on them directly)
     let input = list_concat(input, accs_onto(accs, store(ListNode.Nil)));
     -- sample constraint challenge α (not observed)
     let (a0, a1, input, _oa) = ch_sample_ext(input, store(ListNode.Nil));
     -- observe quotient commitment
-    let input = snoc_cap(input, q);
+    let input = snoc_commitment(input, q);
     -- sample out-of-domain point ζ; keep the resulting `input` for the PCS phase
     let (z0, z1, zinput, _oz) = ch_sample_ext(input, store(ListNode.Nil));
-    ([@gl_val(l0), @gl_val(l1)],
-     [@gl_val(f0), @gl_val(f1)],
-     [@gl_val(a0), @gl_val(a1)],
-     [@gl_val(z0), @gl_val(z1)],
+    ([@val_from_bytes(l0), @val_from_bytes(l1)],
+     [@val_from_bytes(f0), @val_from_bytes(f1)],
+     [@val_from_bytes(a0), @val_from_bytes(a1)],
+     [@val_from_bytes(z0), @val_from_bytes(z1)],
      zinput)
   }
 
-  -- ==========================================================================
-  -- OOD evaluation domain math (`TwoAdicMultiplicativeCoset`, Goldilocks).
-  -- The trace domain for a circuit of size 2^L is the order-2^L subgroup H
-  -- (shift = 1) generated by `two_adic_gen(L)`.
-  -- ==========================================================================
-
-  -- e^(2^k) in the extension field.
-  fn ext_exp_pow2(e: Ext, k: G) -> Ext {
-    match k {
-      0 => e,
-      _ => ext_exp_pow2(@eg_mul(e, e), k - 1),
-    }
-  }
-
-  -- `two_adic_generator(bits)` — a primitive 2^bits root of unity in
-  -- Goldilocks, derived by repeated squaring from the maximal (2^32)
-  -- generator: `g_k = g_{k+1}^2` (matches Plonky3's TWO_ADIC_GENERATORS
-  -- table, checked value-by-value). The 33-arm table cost 32 default-arm
-  -- aux + 33 selectors; the chain is one short memoized circuit — the
-  -- first call materialises ≤ 32 rows, every later call is a cache hit.
-  -- Callers must keep `bits ≤ 32` (guarded where `bits` comes from proof
-  -- advice: log_degrees in `ood_loop`, log_gmax in `pcs_fri_verify`);
-  -- an unguarded larger value would recurse without a base case.
-  fn two_adic_gen(bits: G) -> Goldilocks {
-    match bits {
-      0  => 1,
-      32 => 1753635133440165772,
-      _  =>
-        let g = two_adic_gen(bits + 1);
-        g * g,
-    }
-  }
-
-  -- Vanishing polynomial of the trace domain (shift = 1, size 2^L) at point ζ:
-  -- `Z_H(ζ) = ζ^(2^L) - 1`.
-  fn trace_vanishing(zeta: Ext, l: G) -> Ext {
-    @eg_sub(ext_exp_pow2(zeta, l), [1, 0])
-  }
-
-  -- Lagrange selectors at ζ for the trace domain (shift = 1), mirroring
-  -- `domain.rs::selectors_at_point`:
-  --   is_first_row   = Z_H(ζ) / (ζ - 1)
-  --   is_last_row    = Z_H(ζ) / (ζ - g⁻¹)
-  --   is_transition  = ζ - g⁻¹
-  --   inv_vanishing  = 1 / Z_H(ζ)
-  -- where g = two_adic_gen(L) is the subgroup generator.
-  -- 2^l as a field value (l is a small log-height).
-  fn pow2(l: G) -> G {
-    match l {
-      0 => 1,
-      _ => 2 * pow2(l - 1),
-    }
-  }
-
-  fn trace_selectors(zeta: Ext, l: G) -> (Ext, Ext, Ext, Ext) {
-    let zh = @trace_vanishing(zeta, l);
-    let ginv = @gl_inverse(two_adic_gen(l));
-    let is_first = @eg_div(zh, @eg_sub(zeta, [1, 0]));
-    let is_last = @eg_div(zh, @eg_sub(zeta, [ginv, 0]));
-    let is_trans = @eg_sub(zeta, [ginv, 0]);
-    let inv_van = @eg_inverse(zh);
-    (is_first, is_last, is_trans, inv_van)
-  }
-
   -- Structural + accumulator + PCS checks of a deserialized proof (steps 1, 2,
   -- 4). Fiat-Shamir (step 3) and the OOD check (step 5) live in `ood_verify`,
   -- which needs the verifying key and the claims.
@@ -488,13 +207,13 @@ def verifier := ⟦
   -- One Horner fold step of the constraint folder: `acc := acc·α + x`
   -- (`VerifierConstraintFolder::assert_zero` / `assert_zero_ext`).
   fn ood_fold(acc: Ext, alpha: Ext, x: Ext) -> Ext {
-    @eg_add(@eg_mul(acc, alpha), x)
+    @ext_add(@ext_mul(acc, alpha), x)
   }
 
   -- Reconstruct an extension element from its two opened base coordinates,
   -- `from_ext_basis([c0, c1]) = c0 + c1·X` (the ExtVal basis is `[1, X]`).
   fn from_ext_basis(c0: Ext, c1: Ext) -> Ext {
-    @eg_add(c0, @eg_mul(c1, [0, 1]))
+    @ext_add(c0, @ext_mul(c1, [@val_zero(), @val_one()]))
   }
 
   -- A stage-2 / quotient opened row arrives as `stage_2_width·2` extension
@@ -535,7 +254,7 @@ def verifier := ⟦
       isf: Ext, isl: Ext, ist: Ext) -> Ext {
     let nd = list_lookup(nodes, i);
     match nd {
-      SysNode.Const(c) => [c, 0],
+      SysNode.Const(c) => [c, @val_zero()],
       SysNode.Var(src, off, idx) =>
         -- flatten (source, offset) into one selector: 2·source + offset,
         -- with source 0 Preprocessed / 1 Main / 2 Stage2, offset 0 cur / 1 next.
@@ -553,16 +272,16 @@ def verifier := ⟦
       SysNode.IsLastRow => isl,
       SysNode.IsTransition => ist,
       SysNode.Add(a, b) =>
-        @eg_add(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
+        @ext_add(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
                eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)),
       SysNode.Sub(a, b) =>
-        @eg_sub(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
+        @ext_sub(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
                eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)),
       SysNode.Mul(a, b) =>
-        @eg_mul(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
+        @ext_mul(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
                eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)),
       SysNode.Neg(a) =>
-        @eg_neg(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)),
+        @ext_neg(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)),
     }
   }
 
@@ -598,8 +317,8 @@ def verifier := ⟦
   -- (a0·b0 + 7·a1·b1, a0·b1 + a1·b0).
   -- ==========================================================================
   fn pair_mul(a0: Ext, a1: Ext, b0: Ext, b1: Ext) -> (Ext, Ext) {
-    (@eg_add(@eg_mul(a0, b0), @eg_mul([7, 0], @eg_mul(a1, b1))),
-     @eg_add(@eg_mul(a0, b1), @eg_mul(a1, b0)))
+    (@ext_add(@ext_mul(a0, b0), @ext_mul([@ext_w(), @val_zero()], @ext_mul(a1, b1))),
+     @ext_add(@ext_mul(a0, b1), @ext_mul(a1, b0)))
   }
 
   -- fingerprint(γ, args) = Σᵢ argsᵢ·γ^i as a coordinate pair:
@@ -609,14 +328,14 @@ def verifier := ⟦
       s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›,
       isf: Ext, isl: Ext, ist: Ext) -> (Ext, Ext) {
     match load(args) {
-      ListNode.Nil => ([0, 0], [0, 0]),
+      ListNode.Nil => ([@val_zero(), @val_zero()], [@val_zero(), @val_zero()]),
       ListNode.Cons(a, rest) =>
         let (f0, f1) = logup_fingerprint(rest, g0, g1, nodes,
           main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist);
         let (m0, m1) = pair_mul(f0, f1, g0, g1);
         let av = eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next,
                          publics, isf, isl, ist);
-        (@eg_add(m0, av), m1),
+        (@ext_add(m0, av), m1),
     }
   }
 
@@ -646,14 +365,14 @@ def verifier := ⟦
         let SysLookup.Mk(mid, args) = lk;
         let (f0, f1) = logup_fingerprint(args, g0, g1, nodes,
           main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist);
-        let m0 = @eg_add(f0, b0);
-        let m1 = @eg_add(f1, b1);
+        let m0 = @ext_add(f0, b0);
+        let m1 = @ext_add(f1, b1);
         let mv = eval_at(nodes, mid, main, main_next, prep, prep_next, s2, s2next,
                          publics, isf, isl, ist);
         -- R ← R·m + mult·P, then P ← P·m.
         let (rm0, rm1) = pair_mul(r0, r1, m0, m1);
-        let nr0 = @eg_add(rm0, @eg_mul(mv, p0));
-        let nr1 = @eg_add(rm1, @eg_mul(mv, p1));
+        let nr0 = @ext_add(rm0, @ext_mul(mv, p0));
+        let nr1 = @ext_add(rm1, @ext_mul(mv, p1));
         let (np0, np1) = pair_mul(p0, p1, m0, m1);
         match (j + 1 - lcount) {
           0 =>
@@ -661,10 +380,10 @@ def verifier := ⟦
             -- the wrap target.
             let s0 = list_lookup(s2, g + g);
             let s1 = list_lookup(s2, g + g + 1);
-            let t0 = @eg_add(list_lookup(s2next, 0), inj0);
-            let t1 = @eg_add(list_lookup(s2next, 1), inj1);
-            let (c0, c1) = pair_mul(np0, np1, @eg_sub(t0, s0), @eg_sub(t1, s1));
-            ood_fold(ood_fold(acc, alpha, @eg_sub(c0, nr0)), alpha, @eg_sub(c1, nr1)),
+            let t0 = @ext_add(list_lookup(s2next, 0), inj0);
+            let t1 = @ext_add(list_lookup(s2next, 1), inj1);
+            let (c0, c1) = pair_mul(np0, np1, @ext_sub(t0, s0), @ext_sub(t1, s1));
+            ood_fold(ood_fold(acc, alpha, @ext_sub(c0, nr0)), alpha, @ext_sub(c1, nr1)),
           _ => match rem - 1 {
             0 =>
               -- Group full: close against the next slot, reset the state.
@@ -672,11 +391,11 @@ def verifier := ⟦
               let s1 = list_lookup(s2, g + g + 1);
               let t0 = list_lookup(s2, g + g + 2);
               let t1 = list_lookup(s2, g + g + 3);
-              let (c0, c1) = pair_mul(np0, np1, @eg_sub(t0, s0), @eg_sub(t1, s1));
-              let acc1 = ood_fold(ood_fold(acc, alpha, @eg_sub(c0, nr0)), alpha,
-                                  @eg_sub(c1, nr1));
+              let (c0, c1) = pair_mul(np0, np1, @ext_sub(t0, s0), @ext_sub(t1, s1));
+              let acc1 = ood_fold(ood_fold(acc, alpha, @ext_sub(c0, nr0)), alpha,
+                                  @ext_sub(c1, nr1));
               logup_steps_fold(acc1, alpha, rest, j + 1, lcount,
-                g + 1, k, k, [1, 0], [0, 0], [0, 0], [0, 0],
+                g + 1, k, k, [@val_one(), @val_zero()], [@val_zero(), @val_zero()], [@val_zero(), @val_zero()], [@val_zero(), @val_zero()],
                 inj0, inj1, b0, b1, g0, g1, nodes,
                 main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
             _ =>
@@ -699,33 +418,33 @@ def verifier := ⟦
       main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›,
       s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›,
       lch: Ext, fch: Ext, accp: Ext, naccp: Ext,
-      isf: Ext, isl: Ext, ist: Ext, alpha: Ext, inorm: G) -> Ext {
-    let base = fold_roots([0, 0], alpha, zeros, nodes,
+      isf: Ext, isl: Ext, ist: Ext, alpha: Ext, inorm: Val) -> Ext {
+    let base = fold_roots([@val_zero(), @val_zero()], alpha, zeros, nodes,
                main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist);
     -- The lookup-argument coordinates come straight from the challenge /
     -- accumulator values (pure wiring) — `publics` is only for the node
     -- graph's Public(idx) leaves; looking these 8 back out of the list cost
     -- 8 calls for values already in hand.
-    let b0 = [lch[0], 0]; let b1 = [lch[1], 0];
-    let g0 = [fch[0], 0]; let g1 = [fch[1], 0];
-    let a0 = [accp[0], 0]; let a1 = [accp[1], 0];
-    let na0 = [naccp[0], 0]; let na1 = [naccp[1], 0];
+    let b0 = [lch[0], @val_zero()]; let b1 = [lch[1], @val_zero()];
+    let g0 = [fch[0], @val_zero()]; let g1 = [fch[1], @val_zero()];
+    let a0 = [accp[0], @val_zero()]; let a1 = [accp[1], @val_zero()];
+    let na0 = [naccp[0], @val_zero()]; let na1 = [naccp[1], @val_zero()];
     -- Boundary injection: is_last_row·(acc_final − acc_initial) with the
     -- selector's normalization constant 1/(n·g) absorbed into Δ (`inorm`;
     -- p3's raw selector has value n·g at the last row, and Δ is constant
     -- across the domain, mirroring the Rust prover/verifier).
-    let inj0 = @eg_mul(isl, @eg_mul(@eg_sub(na0, a0), [inorm, 0]));
-    let inj1 = @eg_mul(isl, @eg_mul(@eg_sub(na1, a1), [inorm, 0]));
+    let inj0 = @ext_mul(isl, @ext_mul(@ext_sub(na0, a0), [inorm, @val_zero()]));
+    let inj1 = @ext_mul(isl, @ext_mul(@ext_sub(na1, a1), [inorm, @val_zero()]));
     match load(lks) {
       -- No lookups: single pass-through column, acc′ − acc + inj = 0.
       ListNode.Nil =>
         let acc = ood_fold(base, alpha,
-          @eg_add(@eg_sub(list_lookup(s2next, 0), list_lookup(s2, 0)), inj0));
+          @ext_add(@ext_sub(list_lookup(s2next, 0), list_lookup(s2, 0)), inj0));
         ood_fold(acc, alpha,
-          @eg_add(@eg_sub(list_lookup(s2next, 1), list_lookup(s2, 1)), inj1)),
+          @ext_add(@ext_sub(list_lookup(s2next, 1), list_lookup(s2, 1)), inj1)),
       ListNode.Cons(_h, _t) =>
         logup_steps_fold(base, alpha, lks, 0, list_length(lks),
-          0, k, k, [1, 0], [0, 0], [0, 0], [0, 0], inj0, inj1,
+          0, k, k, [@val_one(), @val_zero()], [@val_zero(), @val_zero()], [@val_zero(), @val_zero()], [@val_zero(), @val_zero()], inj0, inj1,
           b0, b1, g0, g1, nodes,
           main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
     }
@@ -736,10 +455,10 @@ def verifier := ⟦
   -- (`EF::from(coord)`). Indexed by the compiled `Public` node index
   -- (`num_publics = 4·D`, `D = 2`).
   fn build_publics(lch: Ext, fch: Ext, accp: Ext, naccp: Ext) -> List‹Ext› {
-    store(ListNode.Cons([lch[0], 0], store(ListNode.Cons([lch[1], 0],
-    store(ListNode.Cons([fch[0], 0], store(ListNode.Cons([fch[1], 0],
-    store(ListNode.Cons([accp[0], 0], store(ListNode.Cons([accp[1], 0],
-    store(ListNode.Cons([naccp[0], 0], store(ListNode.Cons([naccp[1], 0],
+    store(ListNode.Cons([lch[0], @val_zero()], store(ListNode.Cons([lch[1], @val_zero()],
+    store(ListNode.Cons([fch[0], @val_zero()], store(ListNode.Cons([fch[1], @val_zero()],
+    store(ListNode.Cons([accp[0], @val_zero()], store(ListNode.Cons([accp[1], @val_zero()],
+    store(ListNode.Cons([naccp[0], @val_zero()], store(ListNode.Cons([naccp[1], @val_zero()],
     store(ListNode.Nil)))))))))))))))))
   }
 
@@ -759,9 +478,9 @@ def verifier := ⟦
   -- power, starting at 1).
   fn quotient_eval(slices: List‹Ext›, zeta_pow_n: Ext, pow: Ext) -> Ext {
     match load(slices) {
-      ListNode.Nil => [0, 0],
+      ListNode.Nil => [@val_zero(), @val_zero()],
       ListNode.Cons(c, rest) =>
-        @eg_add(@eg_mul(pow, c), quotient_eval(rest, zeta_pow_n, @eg_mul(pow, zeta_pow_n))),
+        @ext_add(@ext_mul(pow, c), quotient_eval(rest, zeta_pow_n, @ext_mul(pow, zeta_pow_n))),
     }
   }
 
@@ -823,7 +542,7 @@ def verifier := ⟦
         let (prep, prep_next) = @ood_prep_rows(prep_opt, list_lookup(prep_indices, i));
         let (isf, isl, ist, invv) = @trace_selectors(zeta, l);
         let publics = @build_publics(lch, fch, accp, naccp);
-        let inorm = @gl_inverse(pow2(l) * two_adic_gen(l));
+        let inorm = @val_inverse(@val_mul(pow2(l), two_adic_gen(l)));
         let comp = @ood_composition(nodes, zeros, lks, k,
                                    main, main_next, prep, prep_next, s2row, s2next,
                                    publics, lch, fch, accp, naccp,
@@ -832,8 +551,8 @@ def verifier := ⟦
         -- into the `qd` slice values (Rust: `quotient_row.chunks_exact(D)`)
         let slices = reconstruct_ext_row(list_lookup(list_lookup(q_opened, i), 0));
         assert_eq!(eq_zero(list_length(slices) - qd), 1);
-        let quot = quotient_eval(slices, ext_exp_pow2(zeta, l), [1, 0]);
-        assert_eq!(@eg_eq(@eg_mul(comp, invv), quot), 1);
+        let quot = quotient_eval(slices, ext_exp_pow2(zeta, l), [@val_one(), @val_zero()]);
+        assert_eq!(@ext_eq(@ext_mul(comp, invv), quot), 1);
         ood_loop(rest, prep_indices, log_degrees, accs, stage1, stage2, prep_opt,
                  q_opened, i + 1, naccp, lch, fch, alpha, zeta),
     }
@@ -843,9 +562,9 @@ def verifier := ⟦
   -- its raw u64 limb to an extension element). Mirrors `lookup::fingerprint`.
   fn fingerprint_vals(fch: Ext, vals: List‹U64›) -> Ext {
     match load(vals) {
-      ListNode.Nil => [0, 0],
+      ListNode.Nil => [@val_zero(), @val_zero()],
       ListNode.Cons(v, rest) =>
-        @eg_add([@gl_val(v), 0], @eg_mul(fch, fingerprint_vals(fch, rest))),
+        @ext_add([@val_from_bytes(v), @val_zero()], @ext_mul(fch, fingerprint_vals(fch, rest))),
     }
   }
 
@@ -856,8 +575,8 @@ def verifier := ⟦
     match load(claims) {
       ListNode.Nil => acc,
       ListNode.Cons(c, rest) =>
-        let msg = @eg_add(lch, fingerprint_vals(fch, c));
-        claims_acc(@eg_add(acc, @eg_inverse(msg)), rest, lch, fch),
+        let msg = @ext_add(lch, fingerprint_vals(fch, c));
+        claims_acc(@ext_add(acc, @ext_inverse(msg)), rest, lch, fch),
     }
   }
 
@@ -867,13 +586,10 @@ def verifier := ⟦
   -- claims, then run the OOD composition/quotient check for every circuit.
   -- Returns 1 on success (any mismatch aborts via `assert_eq!`).
   fn ood_verify(sys: Sys, proof: Proof, claims: List‹List‹U64››, cbytes: ByteStream) -> G {
-    -- The FRI parameters (`log_blowup`, `num_queries`, `commit_pow_bits`,
-    -- `query_pow_bits`) all come from the verifying key, which the public
-    -- statement binds through `system_digest` — no separate public inputs.
+    -- The PCS parameters come from the verifying key, which the public
+    -- statement binds through `system_digest` — no separate public inputs;
+    -- they are opaque here and consumed by the PCS module's `pcs_verify`.
     let Sys.Mk(params, tlimbs, circuits, commit, prep_indices) = sys;
-    let SysParams.Mk(log_blowup, _cap_height, _log_final_poly_len,
-                     _max_log_arity, num_queries, commit_pow_bits,
-                     query_pow_bits) = params;
     let Proof.Mk(active, commitments, accs, log_degrees, opening,
                  q_opened, prep_opt, stage1, stage2) = proof;
     -- Sparse activation: the bitmap covers the canonical circuit set;
@@ -891,19 +607,20 @@ def verifier := ⟦
     let aprep = select_active_prep(prep_indices, active);
     assert_eq!(eq_zero(list_length(acirc) - list_length(accs)), 1);
     let Commitments.Mk(s1c, s2c, qc) = commitments;
-    -- opt_commit_cap stays a cross-circuit call: its two-arm match would
+    -- opt_commitment stays a cross-circuit call: its two-arm match would
     -- make the (spliced) entrypoint branchy, doubling every lookup's
     -- stage-2 cost there — the one small circuit is cheaper.
-    let prep_cap = @opt_commit_cap(commit);
+    let prep_cap = @opt_commitment(commit);
     let (lch, fch, alpha, zeta, post_zeta_input) = @fiat_shamir(tlimbs, active, prep_cap, s1c, s2c, qc, log_degrees, cbytes, accs);
-    let acc0 = claims_acc([0, 0], claims, lch, fch);
+    let acc0 = claims_acc([@val_zero(), @val_zero()], claims, lch, fch);
     -- Step 5: OOD composition/quotient identity for every active circuit.
     let _ood = ood_loop(acirc, aprep, log_degrees, accs, stage1, stage2,
              prep_opt, q_opened, 0, acc0, lch, fch, alpha, zeta);
-    @pcs_fri_verify(post_zeta_input, stage1, stage2, q_opened, prep_opt, opening,
+    -- Step 4: the PCS opening proof — the PCS module's `pcs_verify`, over the
+    -- post-ζ transcript, the opened values, and its own parameters.
+    @pcs_verify(post_zeta_input, stage1, stage2, q_opened, prep_opt, opening,
       s1c, s2c, qc, prep_cap, aprep, log_degrees, zeta,
-      list_length(acirc), log_blowup, num_queries, commit_pow_bits,
-      query_pow_bits)
+      list_length(acirc), params)
   }
 
   -- 1 iff every element of `l` is boolean (0 or 1).
diff --git a/Tests/Main.lean b/Tests/Main.lean
index edc62e8e..edbd6fa3 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -159,9 +159,14 @@ def primaryRunners : List (String × IO UInt32) := [
     | .ok env => LSpec.lspecEachIO rbTreeMapTestCases fun tc => pure (env.runTestCase tc)),
   -- Multi-STARK recursive verifier: `multi-stark` runs the verifier's
   -- primitive self-tests, `recursive-verifier` the full
-  -- factorial-prove → recursive-verify → reject-tampering pipeline.
+  -- factorial-prove → recursive-verify → reject-tampering pipeline, and
+  -- `foreign-verifier` the same pipeline over the byte-limb (stage-3)
+  -- toplevel under the Goldilocks interpreter.
   ("multi-stark", Tests.MultiStark.selfTestSuite),
   ("recursive-verifier", Tests.MultiStark.endToEndSuite),
+  ("foreign-verifier", Tests.MultiStark.foreignEndToEndSuite),
+  -- Stage 3: the KZG wrap of a stage-2-style proof over BLS12-381.
+  ("kzg-verifier", Tests.MultiStark.kzgEndToEndSuite),
 ]
 
 /-- Ignored test runners - expensive, deferred IO actions run only when explicitly requested -/
diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean
index a1b09e14..86e89940 100644
--- a/Tests/MultiStark.lean
+++ b/Tests/MultiStark.lean
@@ -5,6 +5,7 @@ public import Ix.Aiur.Meta
 public import Ix.Aiur.Protocol
 public import Ix.Aiur.Compiler
 public import Ix.MultiStark
+public import Ix.MultiStark.Field.GoldilocksForeign
 public import Blake3.Rust
 
 /-!
@@ -69,13 +70,27 @@ def selfTests : List (Lean.Name × String) := [
   (`pcs_challenger4_test, "PCS challenger continuation (α_pcs/α_fri/β/index) matches reference"),
   (`fri_fold_test, "FRI arity-2 fold_row matches reference"),
   (`ro_fold_test, "open_input reduced-opening math matches reference"),
-  (`gl_addsub_test, "non-native Goldilocks add/sub match reference"),
-  (`gl_muldiv_test, "non-native Goldilocks mul/inverse/div match reference"),
-  (`eg_ops_test, "non-native ExtGoldilocks add/mul/inverse/div match reference"),
+  (`val_addsub_test, "non-native Goldilocks add/sub match reference"),
+  (`val_muldiv_test, "non-native Goldilocks mul/inverse/div match reference"),
+  (`ext_ops_test, "non-native ExtGoldilocks add/mul/inverse/div match reference"),
 ]
 
-/-- Compile the verifier-plus-tests toplevel once, then execute each `*_test`
-entrypoint and assert it returns `1`. -/
+/-- Self-test entrypoints of the FOREIGN (byte-limb) Goldilocks module
+(`Ix/MultiStark/GoldilocksForeign.lean`). Same reference vectors as the
+native form's suite — the interface contract is identical semantics. The
+module compiles as its own toplevel: it is the ALTERNATIVE to
+`goldilocksNative` (same names by design), so it can never merge into the
+verifier toplevel alongside it. -/
+def foreignSelfTests : List (Lean.Name × String) := [
+  (`fg_addsub_test, "foreign (byte-limb) Goldilocks add/sub match reference"),
+  (`fg_muldiv_test, "foreign (byte-limb) Goldilocks mul/inverse match reference"),
+  (`fg_ext_ops_test, "foreign (byte-limb) ExtGoldilocks ops match reference"),
+  (`fg_boundary_test, "foreign (byte-limb) val_from_bytes/val_to_bytes/bytes_lt_modulus/two-adic root"),
+]
+
+/-- Compile the verifier-plus-tests toplevel (and the standalone foreign
+Goldilocks module) once, then execute each `*_test` entrypoint and assert it
+returns `1`. -/
 def selfTestSuite : IO UInt32 := do
   IO.println "multi-stark"
   let top ← match MultiStark.multiStarkTests with
@@ -84,11 +99,15 @@ def selfTestSuite : IO UInt32 := do
   let compiled ← match top.compile with
     | .error e => IO.eprintln s!"verifier-tests compilation failed: {e}"; return 1
     | .ok c => pure c
-  lspecEachIO selfTests fun (name, desc) => pure <|
-    match compiled.getFuncIdx name with
+  let foreignCompiled ← match MultiStark.goldilocksForeign.compile with
+    | .error e => IO.eprintln s!"goldilocks-foreign compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let cases := selfTests.map (compiled, ·) ++ foreignSelfTests.map (foreignCompiled, ·)
+  lspecEachIO cases fun (unit, (name, desc)) => pure <|
+    match unit.getFuncIdx name with
     | none => test s!"{name}: {desc} — entrypoint not found" false
     | some idx =>
-      match compiled.bytecode.execute idx #[] default with
+      match unit.bytecode.execute idx #[] default with
       | .error e => test s!"{name}: {desc} — execution failed: {e}" false
       | .ok (output, _, _) => test s!"{name}: {desc}" (output == #[Aiur.G.ofNat 1])
 
@@ -226,6 +245,125 @@ def endToEndSuite : IO UInt32 := do
     expectErr "tampered claim rejected (OOD/accumulator mismatch)" tamperedClaim,
   ])]) []
 
+-- ════════════════════════════════════════════════════════════════════════════
+-- `foreign-verifier`: the SAME pipeline over `multiStarkForeign` — the
+-- byte-limb (outer-field-independent) verifier toplevel, stage 3's program
+-- ════════════════════════════════════════════════════════════════════════════
+
+/-- Phase-B gate of `docs/kzg-stage.md`: the foreign (byte-limb Goldilocks)
+verifier toplevel, executed under the existing Goldilocks interpreter against
+the same factorial stage-2 vectors the native verifier passes. The foreign
+module's semantics are outer-field-independent (byte gadgets and carry
+chains), so acceptance here validates the exact program that stage 3 proves
+over the BLS12-381 scalar field — before any Fr machinery exists. Interpreter
+only: the foreign toplevel has no codegen'd runner yet. -/
+def foreignEndToEndSuite : IO UInt32 := do
+  -- ── factorial system + proof (same recipe as `endToEndSuite`) ─────────────
+  let facCompiled ← match factorialProgram.compile with
+    | .error e => IO.eprintln s!"factorial compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let facSystem := AiurSystem.build facCompiled.bytecode recCommitParams innerFri
+  let facIdx ← match facCompiled.getFuncIdx `fact_entry with
+    | some i => pure i
+    | none => IO.eprintln "fact_entry entrypoint not found"; return 1
+  let (claim, proof, _) := facSystem.prove facIdx #[Aiur.G.ofNat 5] default
+  let proofBytes := proof.toBytes
+  let proofGs : Array Aiur.G := proofBytes.data.map .ofUInt8
+  let vkBytes := facSystem.vkBytes
+  let vkGs : Array Aiur.G := vkBytes.data.map .ofUInt8
+  let claimBytes := serializeClaims #[claim]
+  let claimGs : Array Aiur.G := claimBytes.data.map .ofUInt8
+  let pubInput : Array Aiur.G := MultiStark.verifierPubInput vkBytes claimBytes
+  let mkIO := fun (pGs cGs : Array Aiur.G) =>
+    (((default : IOBuffer).extend 0 #[Aiur.G.ofNat 0] pGs).extend 1 #[Aiur.G.ofNat 0] vkGs).extend
+      2 #[Aiur.G.ofNat 0] cGs
+
+  -- ── the FOREIGN production toplevel ───────────────────────────────────────
+  let vTop ← match MultiStark.multiStarkForeign with
+    | .error e => IO.eprintln s!"foreign toplevel merge failed: {e}"; return 1
+    | .ok t => pure t
+  let vCompiled ← match vTop.compile with
+    | .error e => IO.eprintln s!"foreign compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let vIdx ← match vCompiled.getFuncIdx `verify_multi_stark_proof with
+    | some i => pure i
+    | none => IO.eprintln "verify_multi_stark_proof entrypoint not found"; return 1
+
+  -- ── tampered inputs (same tampering as the native suite) ──────────────────
+  let badProofBytes :=
+    proofBytes.set! 0 (UInt8.ofNat ((proofBytes.data[0]!.toNat + 1) % 256))
+  let badProofGs : Array Aiur.G := badProofBytes.data.map .ofUInt8
+  let badClaim : Array Aiur.G := claim.set! (claim.size - 1) (Aiur.G.ofNat 121)
+  let badClaimBytes := serializeClaims #[badClaim]
+  let badClaimGs : Array Aiur.G := badClaimBytes.data.map .ofUInt8
+  let badClaimInput : Array Aiur.G :=
+    MultiStark.verifierPubInput vkBytes badClaimBytes
+
+  IO.println "foreign-verifier (byte-limb Goldilocks, interpreted; slow)…"
+  let honest := vCompiled.bytecode.execute vIdx pubInput (mkIO proofGs claimGs)
+  let tamperedProof := vCompiled.bytecode.execute vIdx pubInput (mkIO badProofGs claimGs)
+  let tamperedClaim :=
+    vCompiled.bytecode.execute vIdx badClaimInput (mkIO proofGs badClaimGs)
+  lspecIO (.ofList [("foreign-verifier", [
+    expectOk "foreign verifier accepts honest proof (byte-limb Goldilocks)" honest,
+    expectErr "tampered proof advice rejected (foreign)" tamperedProof,
+    expectErr "tampered claim rejected (foreign)" tamperedClaim,
+  ])]) []
+
+-- ════════════════════════════════════════════════════════════════════════════
+-- `kzg-verifier`: stage 3 end-to-end at toy scale — wrap a stage-2-style
+-- proof in a KZG proof over the BLS12-381 scalar field, verify natively
+-- ════════════════════════════════════════════════════════════════════════════
+
+/-- Phase-D gate of `docs/kzg-stage.md`: prove factorial under
+Goldilocks/FRI (the stage-1/2 stand-in), then prove the FOREIGN verifier's
+acceptance of that proof over the BLS12-381 scalar field under the KZG
+backend, and verify the wrap natively (two pairings). Dev-grade SRS. -/
+def kzgEndToEndSuite : IO UInt32 := do
+  -- ── inner proof (same recipe as the foreign suite) ────────────────────────
+  let facCompiled ← match factorialProgram.compile with
+    | .error e => IO.eprintln s!"factorial compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let facSystem := AiurSystem.build facCompiled.bytecode recCommitParams innerFri
+  let facIdx ← match facCompiled.getFuncIdx `fact_entry with
+    | some i => pure i
+    | none => IO.eprintln "fact_entry entrypoint not found"; return 1
+  let (claim, proof, _) := facSystem.prove facIdx #[Aiur.G.ofNat 5] default
+  let proofBytes := proof.toBytes
+  let vkBytes := facSystem.vkBytes
+  let claimBytes := serializeClaims #[claim]
+  let pubInput : Array Aiur.G := MultiStark.verifierPubInput vkBytes claimBytes
+
+  -- ── the foreign toplevel, specialized to the scalar field ─────────────────
+  let vTop ← match MultiStark.multiStarkForeign with
+    | .error e => IO.eprintln s!"foreign toplevel merge failed: {e}"; return 1
+    | .ok t => pure t
+  let vCompiled ← match vTop.compile with
+    | .error e => IO.eprintln s!"foreign compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let vIdx ← match vCompiled.getFuncIdx `verify_multi_stark_proof with
+    | some i => pure i
+    | none => IO.eprintln "verify_multi_stark_proof entrypoint not found"; return 1
+
+  IO.println "kzg-verifier (stage-3 wrap over BLS12-381; dev SRS)…"
+  let kzgSystem := AiurKzgSystem.build vCompiled.bytecode 17 4
+  let (wrapClaim, wrapProofBytes) :=
+    kzgSystem.proveMultiStark vIdx pubInput proofBytes vkBytes claimBytes
+  let expectedClaim := buildClaim vIdx pubInput #[]
+  let honest := kzgSystem.verify wrapClaim wrapProofBytes
+  -- Tamper with the wrap proof: the native KZG verifier must reject.
+  let badWrap := wrapProofBytes.set! 0
+    (UInt8.ofNat ((wrapProofBytes.data[0]!.toNat + 1) % 256))
+  let tampered := kzgSystem.verify wrapClaim badWrap
+  IO.println s!"  wrap proof: {wrapProofBytes.size} bytes \
+    (inner stage-2-style proof: {proofBytes.size} bytes)"
+  lspecIO (.ofList [("kzg-verifier", [
+    test "wrap claim = #[functionChannel, vIdx] ++ pubInput" (wrapClaim == expectedClaim),
+    expectOk "native KZG verify accepts the wrap proof (two pairings)" honest,
+    expectErr "tampered wrap proof rejected" tampered,
+  ])]) []
+
+
 end Tests.MultiStark
 
 end
diff --git a/crates/aiur/Cargo.toml b/crates/aiur/Cargo.toml
index 9061574a..257ee348 100644
--- a/crates/aiur/Cargo.toml
+++ b/crates/aiur/Cargo.toml
@@ -18,6 +18,7 @@ tracing-texray = { workspace = true }
 [features]
 default = []
 parallel = ["multi-stark/parallel"]
+kzg = ["multi-stark/kzg"]
 
 [lints]
 workspace = true
diff --git a/crates/aiur/src/bytecode.rs b/crates/aiur/src/bytecode.rs
index 57e426e8..129d51da 100644
--- a/crates/aiur/src/bytecode.rs
+++ b/crates/aiur/src/bytecode.rs
@@ -2,13 +2,13 @@ use crate::FxIndexMap;
 
 use super::G;
 
-pub struct Toplevel {
-  pub functions: Vec<Function>,
+pub struct Toplevel<F = G> {
+  pub functions: Vec<Function<F>>,
   pub memory_sizes: Vec<usize>,
 }
 
-pub struct Function {
-  pub body: Block,
+pub struct Function<F = G> {
+  pub body: Block<F>,
   pub layout: FunctionLayout,
   pub entry: bool,
   pub constrained: bool,
@@ -28,13 +28,13 @@ impl FunctionLayout {
   }
 }
 
-pub struct Block {
-  pub ops: Vec<Op>,
-  pub ctrl: Ctrl,
+pub struct Block<F = G> {
+  pub ops: Vec<Op<F>>,
+  pub ctrl: Ctrl<F>,
 }
 
-pub enum Op {
-  Const(G),
+pub enum Op<F = G> {
+  Const(F),
   Add(ValIdx, ValIdx),
   Sub(ValIdx, ValIdx),
   Mul(ValIdx, ValIdx),
@@ -85,20 +85,27 @@ pub enum Op {
   UnconstrainedU32Add(Vec<ValIdx>, Vec<ValIdx>),
   UnconstrainedU32Add3(Vec<ValIdx>, Vec<ValIdx>, Vec<ValIdx>),
   U32ToField(Vec<ValIdx>),
+  /// Unconstrained hint: `(q, r)` with `v = q·p_goldilocks + r`, `r < p`,
+  /// over the canonical integer of the value. Two fresh auxiliary values,
+  /// no constraints; the caller pins them.
+  UnconstrainedGlDivMod(ValIdx),
+  /// Unconstrained hint: the inverse modulo p_goldilocks of a canonical
+  /// value `< p` (`0 ↦ 0`). One fresh auxiliary value, no constraints.
+  UnconstrainedGlInverse(ValIdx),
 }
 
-pub enum Ctrl {
-  Match(ValIdx, FxIndexMap<G, Block>, Option<Box<Block>>),
+pub enum Ctrl<F = G> {
+  Match(ValIdx, FxIndexMap<F, Block<F>>, Option<Box<Block<F>>>),
   Return(SelIdx, Vec<ValIdx>),
   Yield(SelIdx, Vec<ValIdx>),
   MatchContinue(
     ValIdx,
-    FxIndexMap<G, Block>,
-    Option<Box<Block>>,
-    usize,      // output_size
-    usize,      // shared_auxiliaries
-    usize,      // shared_lookups
-    Box<Block>, // continuation
+    FxIndexMap<F, Block<F>>,
+    Option<Box<Block<F>>>,
+    usize,         // output_size
+    usize,         // shared_auxiliaries
+    usize,         // shared_lookups
+    Box<Block<F>>, // continuation
   ),
 }
 
diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs
index 26488ce5..30ff72e5 100644
--- a/crates/aiur/src/constraints.rs
+++ b/crates/aiur/src/constraints.rs
@@ -1,11 +1,8 @@
-use multi_stark::{
-  lookup::Lookup,
-  p3_field::{Field, PrimeCharacteristicRing},
-};
-use std::{array, ops::Range, sync::LazyLock};
+use multi_stark::lookup::Lookup;
+use std::{array, ops::Range};
 
 use crate::{
-  FxIndexMap, G,
+  AiurField, FxIndexMap,
   bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel, ValIdx},
   function_channel,
   gadgets::{
@@ -19,38 +16,40 @@ use crate::{
   u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel,
 };
 
-type Expr = multi_stark::expr::Expr<G>;
+type Expr<F> = multi_stark::expr::Expr<F>;
 type Degree = u8;
 
 /// Main-trace column variable at index `i`.
 #[inline]
-fn var(i: usize) -> Expr {
+fn var<F: AiurField>(i: usize) -> Expr<F> {
   Expr::main(u32::try_from(i).expect("column index exceeds u32"))
 }
 
 /// Base-field constant expression.
 #[inline]
-fn konst(value: G) -> Expr {
+fn konst<F: AiurField>(value: F) -> Expr<F> {
   Expr::constant(value)
 }
 
-/// `256⁻¹` in the Goldilocks field. The field inversion is expensive, so it is
-/// computed once and reused by the byte carry-chain constraints.
-static INV_256: LazyLock<G> = LazyLock::new(|| G::from_u64(256).inverse());
-/// Constant expression for `(2^32)⁻¹`, built once from its Goldilocks
-/// value and cloned into every virtual u32 carry.
-static INV_2_POW_32_EXPR: LazyLock<Expr> =
-  LazyLock::new(|| konst(G::from_u64(0xffff_fffe_0000_0002)));
-
-fn pack_u32_expr(
-  bytes: impl ExactSizeIterator<Item = (Expr, Degree)>,
-) -> (Expr, Degree) {
+/// `256⁻¹` in the field, for the byte carry-chain constraints (built per
+/// use; constraint synthesis is one-shot, so the inversions are noise).
+fn inv_256<F: AiurField>() -> F {
+  F::from_u64(256).inverse()
+}
+/// Constant expression for `(2^32)⁻¹`.
+fn inv_2_pow_32_expr<F: AiurField>() -> Expr<F> {
+  konst(F::from_u64(1u64 << 32).inverse())
+}
+
+fn pack_u32_expr<F: AiurField>(
+  bytes: impl ExactSizeIterator<Item = (Expr<F>, Degree)>,
+) -> (Expr<F>, Degree) {
   assert_eq!(bytes.len(), 4, "u32 operation requires four bytes");
   bytes.enumerate().fold(
-    (konst(G::ZERO), 0),
+    (konst(F::ZERO), 0),
     |(expr, degree), (i, (byte, byte_degree))| {
       (
-        expr + byte * konst(G::from_u64(1_u64 << (8 * i))),
+        expr + byte * konst(F::from_u64(1_u64 << (8 * i))),
         degree.max(byte_degree),
       )
     },
@@ -58,26 +57,26 @@ fn pack_u32_expr(
 }
 
 /// Holds data for a function circuit.
-pub struct Constraints {
-  pub zeros: Vec<Expr>,
+pub struct Constraints<F> {
+  pub zeros: Vec<Expr<F>>,
   pub selectors: Range<usize>,
   pub width: usize,
 }
 
-struct ConstraintState {
-  function_index: G,
+struct ConstraintState<F> {
+  function_index: F,
   /// Exactly one selector: the function has a single leaf block (no
   /// matches), so every lookup slot is written by exactly one branch.
   branchless: bool,
   layout: FunctionLayout,
   column: usize,
   lookup: usize,
-  lookups: Vec<Lookup<Expr>>,
-  map: Vec<(Expr, Degree)>,
-  constraints: Constraints,
+  lookups: Vec<Lookup<Expr<F>>>,
+  map: Vec<(Expr<F>, Degree)>,
+  constraints: Constraints<F>,
   /// Yield info collected from branches, used by MatchContinue.
   /// NOT part of save/restore so yields persist across branch restores.
-  yield_info: Vec<(Expr, Vec<(Expr, Degree)>)>,
+  yield_info: Vec<(Expr<F>, Vec<(Expr<F>, Degree)>)>,
 }
 
 struct SharedState {
@@ -86,7 +85,7 @@ struct SharedState {
   map_len: usize,
 }
 
-impl ConstraintState {
+impl<F: AiurField> ConstraintState<F> {
   fn selector_index(&self, sel: usize) -> usize {
     sel + self.layout.input_size
   }
@@ -100,17 +99,17 @@ impl ConstraintState {
   /// counts, and on inactive (padding) rows a zero multiplicity makes the
   /// message value irrelevant. Degree-1 messages leave the degree headroom
   /// to group two lookups per chained-accumulator step.
-  fn gate(&self, sel: &Expr, arg: Expr) -> Expr {
+  fn gate(&self, sel: &Expr<F>, arg: Expr<F>) -> Expr<F> {
     if self.branchless { arg } else { sel.clone() * arg }
   }
 
-  fn next_lookup(&mut self) -> &mut Lookup<Expr> {
+  fn next_lookup(&mut self) -> &mut Lookup<Expr<F>> {
     let lookup = &mut self.lookups[self.lookup];
     self.lookup += 1;
     lookup
   }
 
-  fn next_auxiliary(&mut self) -> Expr {
+  fn next_auxiliary(&mut self) -> Expr<F> {
     self.column += 1;
     var(self.column - 1)
   }
@@ -130,11 +129,11 @@ impl ConstraintState {
   }
 }
 
-impl Toplevel {
+impl<F: AiurField> Toplevel<F> {
   pub fn build_constraints(
     &self,
     function_index: usize,
-  ) -> (Constraints, Vec<Lookup<Expr>>) {
+  ) -> (Constraints<F>, Vec<Lookup<Expr<F>>>) {
     let function = &self.functions[function_index];
     let constraints = Constraints {
       zeros: vec![],
@@ -142,7 +141,7 @@ impl Toplevel {
       width: function.layout.width(),
     };
     let mut state = ConstraintState {
-      function_index: G::from_usize(function_index),
+      function_index: F::from_usize(function_index),
       branchless: function.layout.selectors == 1,
       layout: function.layout,
       column: 0,
@@ -157,18 +156,18 @@ impl Toplevel {
     // system compiles a constraint vector, so materialize those explicitly.
     for sel in state.constraints.selectors.clone() {
       let s = var(sel);
-      state.constraints.zeros.push(s.clone() * (s - konst(G::ONE)));
+      state.constraints.zeros.push(s.clone() * (s - konst(F::ONE)));
     }
     (state.constraints, state.lookups)
   }
 }
 
-fn empty_lookup() -> Lookup<Expr> {
-  Lookup { multiplicity: konst(G::ZERO), args: vec![] }
+fn empty_lookup<F: AiurField>() -> Lookup<Expr<F>> {
+  Lookup { multiplicity: konst(F::ZERO), args: vec![] }
 }
 
-impl Function {
-  fn build_constraints(&self, state: &mut ConstraintState) {
+impl<F: AiurField> Function<F> {
+  fn build_constraints(&self, state: &mut ConstraintState<F>) {
     // the first columns are occupied by the input, which is also mapped
     state.column += self.layout.input_size;
     (0..self.layout.input_size).for_each(|i| state.map.push((var(i), 1)));
@@ -187,14 +186,14 @@ impl Function {
   }
 }
 
-impl Block {
-  fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState) {
+impl<F: AiurField> Block<F> {
+  fn collect_constraints(&self, sel: Expr<F>, state: &mut ConstraintState<F>) {
     // Boolean constraint for this block's selector
     let block_sel = self.get_block_selector(state);
     state
       .constraints
       .zeros
-      .push(block_sel.clone() * (konst(G::ONE) - block_sel));
+      .push(block_sel.clone() * (konst(F::ONE) - block_sel));
     self.ops.iter().for_each(|op| op.collect_constraints(&sel, state));
     self.ctrl.collect_constraints(sel, state);
   }
@@ -205,13 +204,13 @@ impl Block {
   /// selectors — crucially excluding the MatchContinue's continuation,
   /// whose return selector fires alongside a yield selector and must not
   /// be double-counted.
-  fn get_block_selector(&self, state: &ConstraintState) -> Expr {
+  fn get_block_selector(&self, state: &ConstraintState<F>) -> Expr<F> {
     match &self.ctrl {
       Ctrl::Return(sel, _) | Ctrl::Yield(sel, _) => {
         var(state.selector_index(*sel))
       },
       Ctrl::Match(_, cases, def) | Ctrl::MatchContinue(_, cases, def, ..) => {
-        let mut sel = konst(G::ZERO);
+        let mut sel = konst(F::ZERO);
         for branch in cases.values() {
           sel = sel + branch.get_block_selector(state);
         }
@@ -227,11 +226,11 @@ impl Block {
 /// Process match cases and optional default branch, emitting selector-gated
 /// constraints. Each branch is processed with save/restore so branches share
 /// auxiliary columns. Returns (max_column, max_lookup) across all branches.
-fn collect_branch_constraints(
+fn collect_branch_constraints<F: AiurField>(
   var_idx: ValIdx,
-  cases: &FxIndexMap<G, Block>,
-  def: &Option<Box<Block>>,
-  state: &mut ConstraintState,
+  cases: &FxIndexMap<F, Block<F>>,
+  def: &Option<Box<Block<F>>>,
+  state: &mut ConstraintState<F>,
 ) -> (usize, usize) {
   let (matched, _) = state.map[var_idx].clone();
   let init = state.save();
@@ -254,7 +253,7 @@ fn collect_branch_constraints(
       let inverse = state.next_auxiliary();
       state.constraints.zeros.push(
         branch_sel.clone()
-          * ((matched.clone() - konst(value)) * inverse - konst(G::ONE)),
+          * ((matched.clone() - konst(value)) * inverse - konst(F::ONE)),
       );
     }
     branch.collect_constraints(branch_sel, state);
@@ -265,9 +264,9 @@ fn collect_branch_constraints(
   (max_column, max_lookup)
 }
 
-impl Ctrl {
+impl<F: AiurField> Ctrl<F> {
   #[allow(clippy::needless_pass_by_value)]
-  fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState) {
+  fn collect_constraints(&self, sel: Expr<F>, state: &mut ConstraintState<F>) {
     match self {
       Ctrl::Return(_, values) => {
         // channel and function index
@@ -290,7 +289,7 @@ impl Ctrl {
       },
       Ctrl::Yield(sel, values) => {
         let yield_sel = var(state.selector_index(*sel));
-        let yield_vals: Vec<(Expr, Degree)> =
+        let yield_vals: Vec<(Expr<F>, Degree)> =
           values.iter().map(|&v| state.map[v].clone()).collect();
         state.yield_info.push((yield_sel, yield_vals));
       },
@@ -326,7 +325,7 @@ impl Ctrl {
         let cont_sel = yields
           .iter()
           .map(|(sel, _)| sel.clone())
-          .fold(konst(G::ZERO), |a, b| a + b);
+          .fold(konst(F::ZERO), |a, b| a + b);
 
         // Merge constraints, gated by the parent selector `sel`. Gating is
         // required because a matchContinue inside a tail match branch may be
@@ -337,7 +336,7 @@ impl Ctrl {
           let sum = yields
             .iter()
             .map(|(sel_j, vals)| sel_j.clone() * vals[i].0.clone())
-            .fold(konst(G::ZERO), |a, b| a + b);
+            .fold(konst(F::ZERO), |a, b| a + b);
           state.constraints.zeros.push(sel.clone() * (merged.clone() - sum));
           state.map.push((merged, 1));
         }
@@ -353,8 +352,8 @@ impl Ctrl {
   }
 }
 
-impl Op {
-  fn collect_constraints(&self, sel: &Expr, state: &mut ConstraintState) {
+impl<F: AiurField> Op<F> {
+  fn collect_constraints(&self, sel: &Expr<F>, state: &mut ConstraintState<F>) {
     match self {
       Op::Const(f) => state.map.push(((*f).into(), 0)),
       Op::Add(a, b) => {
@@ -386,7 +385,7 @@ impl Op {
         let (a, deg) = state.map[*a].clone();
         if let Expr::Const(a) = a {
           assert_eq!(deg, 0);
-          state.map.push((konst(G::from_bool(a == G::ZERO)), 0));
+          state.map.push((konst(F::from_bool(a == F::ZERO)), 0));
         } else {
           // We have two constraints:
           // 1. ax = 0
@@ -402,7 +401,7 @@ impl Op {
           state
             .constraints
             .zeros
-            .push(sel.clone() * (a * d + x.clone() - konst(G::ONE)));
+            .push(sel.clone() * (a * d + x.clone() - konst(F::ONE)));
           state.map.push((x, 1));
         }
       },
@@ -417,14 +416,14 @@ impl Op {
           // channel and function index
           let mut lookup_args = vec![
             state.gate(sel, konst(function_channel())),
-            state.gate(sel, konst(G::from_usize(*function_index))),
+            state.gate(sel, konst(F::from_usize(*function_index))),
           ];
           // input
           lookup_args.extend(
             inputs.iter().map(|arg| state.gate(sel, state.map[*arg].0.clone())),
           );
           // output
-          let output: Vec<Expr> = (0..*output_size)
+          let output: Vec<Expr<F>> = (0..*output_size)
             .map(|_| {
               let col = state.next_auxiliary();
               state.map.push((col.clone(), 1));
@@ -446,7 +445,7 @@ impl Op {
         state.map.push((ptr.clone(), 1));
         let mut lookup_args = vec![
           state.gate(sel, konst(memory_channel())),
-          state.gate(sel, konst(G::from_usize(size))),
+          state.gate(sel, konst(F::from_usize(size))),
           state.gate(sel, ptr),
         ];
         // stored values
@@ -464,11 +463,11 @@ impl Op {
         // channel, size and pointer
         let mut lookup_args = vec![
           state.gate(sel, konst(memory_channel())),
-          state.gate(sel, konst(G::from_usize(*size))),
+          state.gate(sel, konst(F::from_usize(*size))),
           state.gate(sel, state.map[*ptr].0.clone()),
         ];
         // loaded values
-        let values: Vec<Expr> = (0..*size)
+        let values: Vec<Expr<F>> = (0..*size)
           .map(|_| {
             let col = state.next_auxiliary();
             state.map.push((col.clone(), 1));
@@ -545,7 +544,7 @@ impl Op {
         let lookup = state.next_lookup();
         combine_lookup_args(lookup, lookup_args);
         lookup.multiplicity = lookup.multiplicity.clone() + sel.clone();
-        let carry = (x + y - z.clone()) * konst(*INV_256);
+        let carry = (x + y - z.clone()) * konst(inv_256());
         state.map.push((z, 1));
         state.map.push((carry, x_deg.max(y_deg).max(1)));
       },
@@ -561,7 +560,7 @@ impl Op {
           state.map.push((byte, 1));
         }
         state.map.push((
-          (x + y - z) * (*INV_2_POW_32_EXPR).clone(),
+          (x + y - z) * inv_2_pow_32_expr(),
           x_deg.max(y_deg).max(z_deg),
         ));
       },
@@ -579,7 +578,7 @@ impl Op {
           state.map.push((byte, 1));
         }
         state.map.push((
-          (x + y + w - z) * (*INV_2_POW_32_EXPR).clone(),
+          (x + y + w - z) * inv_2_pow_32_expr(),
           x_deg.max(y_deg).max(w_deg).max(z_deg),
         ));
       },
@@ -612,7 +611,7 @@ impl Op {
         let lookup = state.next_lookup();
         combine_lookup_args(lookup, lookup_args);
         lookup.multiplicity = lookup.multiplicity.clone() + sel.clone();
-        let borrow = (z.clone() + y - x) * konst(*INV_256);
+        let borrow = (z.clone() + y - x) * konst(inv_256());
         state.map.push((z, 1));
         state.map.push((borrow, x_deg.max(y_deg).max(1)));
       },
@@ -695,15 +694,15 @@ impl Op {
         let b = state.map[*y_idx].0.clone();
 
         // Byte decomposition auxiliaries
-        let x_bytes: [Expr; 4] = array::from_fn(|_| state.next_auxiliary());
-        let y_bytes: [Expr; 4] = array::from_fn(|_| state.next_auxiliary());
-        let z_bytes: [Expr; 4] = array::from_fn(|_| state.next_auxiliary());
+        let x_bytes: [Expr<F>; 4] = array::from_fn(|_| state.next_auxiliary());
+        let y_bytes: [Expr<F>; 4] = array::from_fn(|_| state.next_auxiliary());
+        let z_bytes: [Expr<F>; 4] = array::from_fn(|_| state.next_auxiliary());
 
         // Decomposition constraints: a = Σ x_k * 256^k, b = Σ z_k * 256^k
         let base =
-          |k: usize| G::from_u64(256u64.pow(u32::try_from(k).unwrap()));
-        let recompose = |bytes: &[Expr; 4]| {
-          bytes.iter().enumerate().fold(konst(G::ZERO), |acc, (k, b)| {
+          |k: usize| F::from_u64(256u64.pow(u32::try_from(k).unwrap()));
+        let recompose = |bytes: &[Expr<F>; 4]| {
+          bytes.iter().enumerate().fold(konst(F::ZERO), |acc, (k, b)| {
             acc + b.clone() * konst(base(k))
           })
         };
@@ -711,12 +710,12 @@ impl Op {
         state.constraints.zeros.push(sel.clone() * (b - recompose(&z_bytes)));
 
         // Carry chain: a + c + 1 = b + carry * 2^32
-        let mut carry = konst(G::ONE); // initial carry = 1 for strict less-than
+        let mut carry = konst(F::ONE); // initial carry = 1 for strict less-than
         for k in 0..4 {
           let sum = x_bytes[k].clone() + y_bytes[k].clone() + carry;
-          carry = (sum - z_bytes[k].clone()) * konst(*INV_256);
+          carry = (sum - z_bytes[k].clone()) * konst(inv_256());
           state.constraints.zeros.push(
-            sel.clone() * (carry.clone() * (carry.clone() - konst(G::ONE))),
+            sel.clone() * (carry.clone() * (carry.clone() - konst(F::ONE))),
           );
         }
 
@@ -741,7 +740,7 @@ impl Op {
         }
 
         // Output: 1 - carry
-        let output = konst(G::ONE) - carry;
+        let output = konst(F::ONE) - carry;
         state.map.push((output, 1));
       },
       Op::IOSetInfo(..) | Op::IOWrite(..) | Op::Debug(..) => (),
@@ -771,25 +770,37 @@ impl Op {
         let col = state.next_auxiliary();
         state.map.push((col, 1));
       },
+      Op::UnconstrainedGlDivMod(_) => {
+        // Two fresh auxiliary columns (q, r), no relation; the caller pins
+        // them with the identity and range checks.
+        for _ in 0..2 {
+          let col = state.next_auxiliary();
+          state.map.push((col, 1));
+        }
+      },
+      Op::UnconstrainedGlInverse(_) => {
+        let col = state.next_auxiliary();
+        state.map.push((col, 1));
+      },
     }
   }
 }
 
-fn bytes1_constraints(
+fn bytes1_constraints<F: AiurField>(
   byte: usize,
   op: &Bytes1Op,
-  channel: G,
-  sel: Expr,
-  state: &mut ConstraintState,
+  channel: F,
+  sel: Expr<F>,
+  state: &mut ConstraintState<F>,
 ) {
-  let size = Bytes1.output_size(op);
+  let size = AiurGadget::<F>::output_size(&Bytes1, op);
 
   let mut lookup_args = vec![
     state.gate(&sel, konst(channel)),
     state.gate(&sel, state.map[byte].0.clone()),
   ];
 
-  let output: Vec<Expr> = (0..size)
+  let output: Vec<Expr<F>> = (0..size)
     .map(|_| {
       let col = state.next_auxiliary();
       state.map.push((col.clone(), 1));
@@ -803,15 +814,15 @@ fn bytes1_constraints(
   lookup.multiplicity = lookup.multiplicity.clone() + sel;
 }
 
-fn bytes2_constraints(
+fn bytes2_constraints<F: AiurField>(
   i: usize,
   j: usize,
   op: &Bytes2Op,
-  channel: G,
-  sel: Expr,
-  state: &mut ConstraintState,
+  channel: F,
+  sel: Expr<F>,
+  state: &mut ConstraintState<F>,
 ) {
-  let size = Bytes2.output_size(op);
+  let size = AiurGadget::<F>::output_size(&Bytes2, op);
 
   let mut lookup_args = vec![
     state.gate(&sel, konst(channel)),
@@ -819,7 +830,7 @@ fn bytes2_constraints(
     state.gate(&sel, state.map[j].0.clone()),
   ];
 
-  let output: Vec<Expr> = (0..size)
+  let output: Vec<Expr<F>> = (0..size)
     .map(|_| {
       let col = state.next_auxiliary();
       state.map.push((col.clone(), 1));
@@ -833,9 +844,9 @@ fn bytes2_constraints(
   lookup.multiplicity = lookup.multiplicity.clone() + sel;
 }
 
-fn combine_lookup_args(
-  lookup: &mut Lookup<Expr>,
-  args: impl IntoIterator<Item = Expr>,
+fn combine_lookup_args<F: AiurField>(
+  lookup: &mut Lookup<Expr<F>>,
+  args: impl IntoIterator<Item = Expr<F>>,
 ) {
   let mut args_iterator = args.into_iter();
   lookup.args.iter_mut().zip(args_iterator.by_ref()).for_each(
diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs
index c7862fb4..26f2f26e 100644
--- a/crates/aiur/src/execute.rs
+++ b/crates/aiur/src/execute.rs
@@ -1,9 +1,8 @@
-use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64};
 use rustc_hash::FxHashMap;
 use std::collections::hash_map::Entry;
 
 use crate::{
-  FxIndexMap, G,
+  AiurField, FxIndexMap, G,
   bytecode::{Block, Ctrl, FunIdx, Function, Op, Toplevel},
   gadgets::{
     AiurGadget,
@@ -13,7 +12,7 @@ use crate::{
   querymap::QueryMap,
 };
 
-fn u32_value(map: &[G], bytes: &[usize]) -> u64 {
+fn u32_value<F: AiurField>(map: &[F], bytes: &[usize]) -> u64 {
   assert_eq!(bytes.len(), 4, "u32 operation requires four bytes");
   bytes
     .iter()
@@ -21,22 +20,22 @@ fn u32_value(map: &[G], bytes: &[usize]) -> u64 {
     .fold(0, |word, (i, idx)| word | (map[*idx].as_canonical_u64() << (8 * i)))
 }
 
-fn u32_sum(values: &[u64]) -> ([G; 4], G) {
+fn u32_sum<F: AiurField>(values: &[u64]) -> ([F; 4], F) {
   let sum: u128 = values.iter().map(|x| u128::from(*x)).sum();
   let word = u32::try_from(sum & 0xFFFF_FFFF).expect("masked to 32 bits");
   let carry = u64::try_from(sum >> 32).expect("sum of u32 words fits in u64");
-  (word.to_le_bytes().map(|b| G::from_u64(b.into())), G::from_u64(carry))
+  (word.to_le_bytes().map(|b| F::from_u64(b.into())), F::from_u64(carry))
 }
 
-pub struct QueryRecord {
-  pub function_queries: Vec<QueryMap>,
-  pub memory_queries: FxIndexMap<usize, QueryMap>,
-  pub bytes1_queries: Bytes1Queries,
-  pub bytes2_queries: Bytes2Queries,
+pub struct QueryRecord<F: Copy = G> {
+  pub function_queries: Vec<QueryMap<F>>,
+  pub memory_queries: FxIndexMap<usize, QueryMap<F>>,
+  pub bytes1_queries: Bytes1Queries<F>,
+  pub bytes2_queries: Bytes2Queries<F>,
 }
 
-impl QueryRecord {
-  pub fn new(toplevel: &Toplevel) -> Self {
+impl<F: AiurField> QueryRecord<F> {
+  pub fn new(toplevel: &Toplevel<F>) -> Self {
     let function_queries = toplevel
       .functions
       .iter()
@@ -58,27 +57,27 @@ pub struct IOKeyInfo {
   pub len: usize,
 }
 
-pub struct IOBuffer {
+pub struct IOBuffer<F = G> {
   /// Per-channel data arenas. `idx` slots into `data[&channel]`.
-  pub data: FxHashMap<G, Vec<G>>,
+  pub data: FxHashMap<F, Vec<F>>,
   /// Channel-keyed info map; same `key` on different channels resolves
   /// to distinct `IOKeyInfo`.
-  pub map: FxHashMap<(G, Vec<G>), IOKeyInfo>,
+  pub map: FxHashMap<(F, Vec<F>), IOKeyInfo>,
 }
 
-impl IOBuffer {
+impl<F: AiurField> IOBuffer<F> {
   #[inline]
   pub fn get_info(
     &self,
-    channel: G,
-    key: &[G],
+    channel: F,
+    key: &[F],
   ) -> Result<&IOKeyInfo, ExecError> {
     self.map.get(&(channel, key.to_vec())).ok_or(ExecError::InvalidIOKey)
   }
   fn set_info(
     &mut self,
-    channel: G,
-    key: Vec<G>,
+    channel: F,
+    key: Vec<F>,
     idx: usize,
     len: usize,
   ) -> Result<(), ExecError> {
@@ -91,17 +90,17 @@ impl IOBuffer {
   #[inline]
   pub fn read(
     &self,
-    channel: G,
+    channel: F,
     idx: usize,
     len: usize,
-  ) -> Result<&[G], ExecError> {
-    let empty: &[G] = &[];
+  ) -> Result<&[F], ExecError> {
+    let empty: &[F] = &[];
     let arena = self.data.get(&channel).map_or(empty, |v| v.as_slice());
     arena
       .get(idx..idx.saturating_add(len))
       .ok_or(ExecError::IOReadOutOfBounds { idx, len })
   }
-  fn write(&mut self, channel: G, data: impl Iterator<Item = G>) {
+  fn write(&mut self, channel: F, data: impl Iterator<Item = F>) {
     self.data.entry(channel).or_default().extend(data)
   }
 }
@@ -195,13 +194,13 @@ impl std::error::Error for ExecError {}
 /// Gated by `IX_AIUR_QUERY_STATS=1`: dump per-function query-map sizes
 /// during/after execution so RAM blowups can be attributed to specific
 /// Aiur functions (indices resolve to names via the Lean
-/// `CompiledToplevel`). Heaviest maps first, by retained G elements.
+/// `CompiledToplevel`). Heaviest maps first, by retained F elements.
 static QUERY_STATS: std::sync::LazyLock<bool> =
   std::sync::LazyLock::new(|| {
     std::env::var_os("IX_AIUR_QUERY_STATS").is_some()
   });
 
-fn dump_query_stats(record: &QueryRecord, tag: &str) {
+fn dump_query_stats<F: AiurField>(record: &QueryRecord<F>, tag: &str) {
   let mut rows: Vec<(usize, usize, usize)> = record
     .function_queries
     .iter()
@@ -214,7 +213,7 @@ fn dump_query_stats(record: &QueryRecord, tag: &str) {
   let total_elems: usize = rows.iter().map(|r| r.2).sum();
   eprintln!(
     "[aiur-stats {tag}] function_queries: {total_entries} entries, \
-     {total_elems} G-elems; top maps:"
+     {total_elems} F-elems; top maps:"
   );
   for (i, n, e) in rows.iter().take(30) {
     eprintln!("  fn{i:<4} entries={n:<12} g_elems={e}");
@@ -227,13 +226,13 @@ fn dump_query_stats(record: &QueryRecord, tag: &str) {
   eprintln!("[aiur-stats {tag}] memory entries: {}", mem.join(" "));
 }
 
-impl Toplevel {
+impl<F: AiurField> Toplevel<F> {
   pub fn execute(
     &self,
     fun_idx: FunIdx,
-    args: Vec<G>,
-    io_buffer: &mut IOBuffer,
-  ) -> Result<(QueryRecord, Vec<G>), ExecError> {
+    args: Vec<F>,
+    io_buffer: &mut IOBuffer<F>,
+  ) -> Result<(QueryRecord<F>, Vec<F>), ExecError> {
     if !self.functions[fun_idx].entry {
       return Err(ExecError::NotEntryFunction(fun_idx));
     }
@@ -248,35 +247,35 @@ impl Toplevel {
   }
 }
 
-enum ExecEntry<'a> {
-  Op(&'a Op),
-  Ctrl(&'a Ctrl),
+enum ExecEntry<'a, F> {
+  Op(&'a Op<F>),
+  Ctrl(&'a Ctrl<F>),
 }
 
-struct CallerState {
+struct CallerState<F> {
   fun_idx: FunIdx,
-  map: Vec<G>,
+  map: Vec<F>,
   unconstrained: bool,
   continuation_depth: usize,
 }
 
-struct ContinuationState<'a> {
-  block: &'a Block,
+struct ContinuationState<'a, F> {
+  block: &'a Block<F>,
   map_len: usize,
 }
 
-impl Function {
+impl<F: AiurField> Function<F> {
   fn execute(
     &self,
     mut fun_idx: FunIdx,
-    mut map: Vec<G>,
-    toplevel: &Toplevel,
-    record: &mut QueryRecord,
-    io_buffer: &mut IOBuffer,
-  ) -> Result<Vec<G>, ExecError> {
+    mut map: Vec<F>,
+    toplevel: &Toplevel<F>,
+    record: &mut QueryRecord<F>,
+    io_buffer: &mut IOBuffer<F>,
+  ) -> Result<Vec<F>, ExecError> {
     let mut exec_entries_stack = vec![];
-    let mut callers_states_stack: Vec<CallerState> = vec![];
-    let mut continuation_stack: Vec<ContinuationState<'_>> = vec![];
+    let mut callers_states_stack: Vec<CallerState<F>> = vec![];
+    let mut continuation_stack: Vec<ContinuationState<'_, F>> = vec![];
     macro_rules! push_block_exec_entries {
       ($block:expr) => {
         exec_entries_stack.push(ExecEntry::Ctrl(&$block.ctrl));
@@ -323,10 +322,10 @@ impl Function {
         },
         ExecEntry::Op(Op::EqZero(a)) => {
           let a = map[*a];
-          map.push(G::from_bool(a == G::ZERO));
+          map.push(F::from_bool(a == F::ZERO));
         },
         ExecEntry::Op(Op::Call(callee_idx, args, _, op_unconstrained)) => {
-          let args: Vec<G> = args.iter().map(|i| map[*i]).collect();
+          let args: Vec<F> = args.iter().map(|i| map[*i]).collect();
           let callee_unconstrained = unconstrained || *op_unconstrained;
           let cached_output = record.function_queries[*callee_idx]
             .get_mut(&args)
@@ -340,7 +339,7 @@ impl Function {
                 None
               } else {
                 if !callee_unconstrained {
-                  *result.multiplicity += G::ONE;
+                  *result.multiplicity += F::ONE;
                 }
                 Some(result.output.to_vec())
               }
@@ -369,15 +368,15 @@ impl Function {
             .ok_or(ExecError::InvalidMemorySize(size))?;
           if let Some(result) = memory_queries.get_mut(&values) {
             if !unconstrained {
-              *result.multiplicity += G::ONE;
+              *result.multiplicity += F::ONE;
             }
             map.extend_from_slice(result.output);
           } else {
-            let ptr = G::from_usize(memory_queries.len());
+            let ptr = F::from_usize(memory_queries.len());
             memory_queries.insert(
               &values,
               &[ptr],
-              G::from_bool(!unconstrained),
+              F::from_bool(!unconstrained),
             );
             map.push(ptr);
           }
@@ -396,7 +395,7 @@ impl Function {
             .get_index_mut(ptr_usize)
             .ok_or(ExecError::UnboundPointer { ptr: ptr_u64, size: *size })?;
           if !unconstrained {
-            *multiplicity += G::ONE;
+            *multiplicity += F::ONE;
           }
           map.extend_from_slice(args);
         },
@@ -423,8 +422,8 @@ impl Function {
           let channel = map[*channel];
           let key = key.iter().map(|v| map[*v]).collect::<Vec<_>>();
           let IOKeyInfo { idx, len } = io_buffer.get_info(channel, &key)?;
-          map.push(G::from_usize(*idx));
-          map.push(G::from_usize(*len));
+          map.push(F::from_usize(*idx));
+          map.push(F::from_usize(*len));
         },
         ExecEntry::Op(Op::IOSetInfo(channel, key, idx, len)) => {
           let channel = map[*channel];
@@ -508,7 +507,7 @@ impl Function {
           map.push(carry);
         },
         ExecEntry::Op(Op::U32ToField(bytes)) => {
-          map.push(G::from_u64(u32_value(&map, bytes)));
+          map.push(F::from_u64(u32_value(&map, bytes)));
         },
         ExecEntry::Op(Op::U8Mul(i, j)) => {
           if unconstrained {
@@ -557,7 +556,7 @@ impl Function {
             u32::try_from(a_val).ok().ok_or(ExecError::U32OutOfRange(a_val))?;
           let b_u32 =
             u32::try_from(b_val).ok().ok_or(ExecError::U32OutOfRange(b_val))?;
-          let result = G::from_bool(a_u32 < b_u32);
+          let result = F::from_bool(a_u32 < b_u32);
           map.push(result);
           if !unconstrained {
             let x_bytes = a_u32.to_le_bytes();
@@ -575,7 +574,7 @@ impl Function {
             ] {
               record
                 .bytes2_queries
-                .bump_range_check(&G::from_u8(i), &G::from_u8(j));
+                .bump_range_check(&F::from_u8(i), &F::from_u8(j));
             }
           }
         },
@@ -622,7 +621,7 @@ impl Function {
           //
           // The `memory[10]` channel is chosen because the standard Aiur
           // layout for a tagged enum with a `(U64, &Self)` constructor is
-          // `tag(1) + U64(8) + ptr(1) = 10` G values.
+          // `tag(1) + U64(8) + ptr(1) = 10` F values.
           let a_ptr = map[*a_idx];
           let b_ptr = map[*b_idx];
           let a_limbs = read_klimbs_u64(&record.memory_queries, a_ptr)
@@ -650,13 +649,21 @@ impl Function {
           // No record side effects — the caller pins the bytes with range
           // checks + a recomposition assert + a canonicality assert.
           let bytes = map[*a_idx].as_canonical_u64().to_le_bytes();
-          map.extend(bytes.iter().map(|b| G::from_u8(*b)));
+          map.extend(bytes.iter().map(|b| F::from_u8(*b)));
         },
         ExecEntry::Op(Op::UnconstrainedGInverse(a_idx)) => {
           // Unconstrained hint: the field inverse (`0 ↦ 0`). No record side
           // effects — the caller pins it via multiply-and-assert.
           map.push(g_inverse_value(map[*a_idx]));
         },
+        ExecEntry::Op(Op::UnconstrainedGlDivMod(a_idx)) => {
+          let (q, r) = gl_divmod_value(map[*a_idx]);
+          map.push(q);
+          map.push(r);
+        },
+        ExecEntry::Op(Op::UnconstrainedGlInverse(a_idx)) => {
+          map.push(gl_inverse_value(map[*a_idx]));
+        },
         ExecEntry::Op(Op::Debug(label, idxs)) => match idxs {
           None => println!("{label}"),
           Some(idxs) => {
@@ -703,7 +710,7 @@ impl Function {
         ExecEntry::Ctrl(Ctrl::Yield(_, output)) => {
           let cont =
             continuation_stack.pop().ok_or(ExecError::NoContinuation)?;
-          let yielded: Vec<G> = output.iter().map(|&v| map[v]).collect();
+          let yielded: Vec<F> = output.iter().map(|&v| map[v]).collect();
           map.truncate(cont.map_len);
           map.extend(yielded);
           push_block_exec_entries!(cont.block);
@@ -719,13 +726,13 @@ impl Function {
             // is constrained promotion of an unconstrained hint entry.
             debug_assert_eq!(result.output, output);
             if !unconstrained {
-              *result.multiplicity += G::ONE;
+              *result.multiplicity += F::ONE;
             }
           } else {
             record.function_queries[fun_idx].insert(
               &map[..input_size],
               &output,
-              G::from_bool(!unconstrained),
+              F::from_bool(!unconstrained),
             );
           }
           if let Some(CallerState {
@@ -755,21 +762,21 @@ impl Function {
   }
 }
 
-pub fn bytes1_execute(
+pub fn bytes1_execute<F: AiurField>(
   byte: usize,
   op: &Bytes1Op,
-  map: &mut Vec<G>,
-  record: &mut QueryRecord,
+  map: &mut Vec<F>,
+  record: &mut QueryRecord<F>,
 ) {
   map.extend(Bytes1.execute(op, &[map[byte]], record));
 }
 
-pub fn bytes2_execute(
+pub fn bytes2_execute<F: AiurField>(
   i: usize,
   j: usize,
   op: &Bytes2Op,
-  map: &mut Vec<G>,
-  record: &mut QueryRecord,
+  map: &mut Vec<F>,
+  record: &mut QueryRecord<F>,
 ) {
   map.extend(Bytes2.execute(op, &[map[i], map[j]], record));
 }
@@ -778,11 +785,11 @@ pub fn bytes2_execute(
 // Per-op value-returning helpers for the codegen'd kernel.
 //
 // The interpreter routes byte ops through `bytes{1,2}_execute(idx, op,
-// &mut Vec<G>, record)` which `extends` the Vec with the gadget's
-// output. The codegen'd kernel doesn't keep a `Vec<G>` value stack
+// &mut Vec<F>, record)` which `extends` the Vec with the gadget's
+// output. The codegen'd kernel doesn't keep a `Vec<F>` value stack
 // (every Aiur ValIdx is a real Rust local), so the wrappers below let
 // it consume gadget outputs as fixed-size arrays / tuples / single Gs
-// without an allocating Vec<G> per op.
+// without an allocating Vec<F> per op.
 //
 // Each helper bumps the same `bytes{1,2}_queries` channel as the
 // interpreter's `Bytes{1,2}::execute` arm, so QueryRecord parity is
@@ -790,18 +797,21 @@ pub fn bytes2_execute(
 // ============================================================================
 
 #[inline]
-pub fn bytes1_bit_decompose_value(byte: G, record: &mut QueryRecord) -> [G; 8] {
+pub fn bytes1_bit_decompose_value<F: AiurField>(
+  byte: F,
+  record: &mut QueryRecord<F>,
+) -> [F; 8] {
   record.bytes1_queries.bump_bit_decomposition(&byte);
   let byte_u64 = byte.as_canonical_u64();
   [
-    G::from_bool(byte_u64 & 1 == 1),
-    G::from_bool(byte_u64 >> 1 & 1 == 1),
-    G::from_bool(byte_u64 >> 2 & 1 == 1),
-    G::from_bool(byte_u64 >> 3 & 1 == 1),
-    G::from_bool(byte_u64 >> 4 & 1 == 1),
-    G::from_bool(byte_u64 >> 5 & 1 == 1),
-    G::from_bool(byte_u64 >> 6 & 1 == 1),
-    G::from_bool(byte_u64 >> 7 & 1 == 1),
+    F::from_bool(byte_u64 & 1 == 1),
+    F::from_bool(byte_u64 >> 1 & 1 == 1),
+    F::from_bool(byte_u64 >> 2 & 1 == 1),
+    F::from_bool(byte_u64 >> 3 & 1 == 1),
+    F::from_bool(byte_u64 >> 4 & 1 == 1),
+    F::from_bool(byte_u64 >> 5 & 1 == 1),
+    F::from_bool(byte_u64 >> 6 & 1 == 1),
+    F::from_bool(byte_u64 >> 7 & 1 == 1),
   ]
 }
 
@@ -809,7 +819,10 @@ pub fn bytes1_bit_decompose_value(byte: G, record: &mut QueryRecord) -> [G; 8] {
 /// of other toplevels that might.
 #[inline]
 #[allow(dead_code)]
-pub fn bytes1_shift_left_value(byte: G, record: &mut QueryRecord) -> G {
+pub fn bytes1_shift_left_value<F: AiurField>(
+  byte: F,
+  record: &mut QueryRecord<F>,
+) -> F {
   record.bytes1_queries.bump_shift_left(&byte);
   Bytes1::shift_left(&byte)
 }
@@ -818,31 +831,50 @@ pub fn bytes1_shift_left_value(byte: G, record: &mut QueryRecord) -> G {
 /// codegen of other toplevels.
 #[inline]
 #[allow(dead_code)]
-pub fn bytes1_shift_right_value(byte: G, record: &mut QueryRecord) -> G {
+pub fn bytes1_shift_right_value<F: AiurField>(
+  byte: F,
+  record: &mut QueryRecord<F>,
+) -> F {
   record.bytes1_queries.bump_shift_right(&byte);
   Bytes1::shift_right(&byte)
 }
 
 #[inline]
-pub fn bytes2_xor_value(a: G, b: G, record: &mut QueryRecord) -> G {
+pub fn bytes2_xor_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> F {
   record.bytes2_queries.bump_xor(&a, &b);
   Bytes2::xor(&a, &b)
 }
 
 #[inline]
-pub fn bytes2_and_value(a: G, b: G, record: &mut QueryRecord) -> G {
+pub fn bytes2_and_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> F {
   record.bytes2_queries.bump_and(&a, &b);
   Bytes2::and(&a, &b)
 }
 
 #[inline]
-pub fn bytes2_or_value(a: G, b: G, record: &mut QueryRecord) -> G {
+pub fn bytes2_or_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> F {
   record.bytes2_queries.bump_or(&a, &b);
   Bytes2::or(&a, &b)
 }
 
 #[inline]
-pub fn bytes2_less_than_value(a: G, b: G, record: &mut QueryRecord) -> G {
+pub fn bytes2_less_than_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> F {
   record.bytes2_queries.bump_less_than(&a, &b);
   Bytes2::less_than(&a, &b)
 }
@@ -851,19 +883,31 @@ pub fn bytes2_less_than_value(a: G, b: G, record: &mut QueryRecord) -> G {
 /// other toplevels.
 #[inline]
 #[allow(dead_code)]
-pub fn bytes2_mul_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) {
+pub fn bytes2_mul_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> (F, F) {
   record.bytes2_queries.bump_mul(&a, &b);
   Bytes2::mul(&a, &b)
 }
 
 #[inline]
-pub fn bytes2_xor_split7_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) {
+pub fn bytes2_xor_split7_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> (F, F) {
   record.bytes2_queries.bump_xor_split7(&a, &b);
   Bytes2::xor_split7(&a, &b)
 }
 
 #[inline]
-pub fn bytes2_xor_split4_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) {
+pub fn bytes2_xor_split4_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> (F, F) {
   record.bytes2_queries.bump_xor_split4(&a, &b);
   Bytes2::xor_split4(&a, &b)
 }
@@ -873,13 +917,21 @@ pub fn bytes2_xor_split4_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) {
 /// chip; carry is derived natively. The codegen path uses this
 /// helper so the add gadget runs exactly once.
 #[inline]
-pub fn bytes2_add_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) {
+pub fn bytes2_add_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> (F, F) {
   record.bytes2_queries.bump_add(&a, &b);
   Bytes2::add(&a, &b)
 }
 
 #[inline]
-pub fn bytes2_sub_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) {
+pub fn bytes2_sub_value<F: AiurField>(
+  a: F,
+  b: F,
+  record: &mut QueryRecord<F>,
+) -> (F, F) {
   record.bytes2_queries.bump_sub(&a, &b);
   Bytes2::sub(&a, &b)
 }
@@ -897,19 +949,36 @@ pub use crate::gadgets::bytes2::Bytes2 as CodegenBytes2;
 /// `0 ↦ 0`. Shared by the interpreter, the codegen'd kernels, and trace
 /// population so all three produce identical witness values.
 #[inline]
-pub fn g_inverse_value(x: G) -> G {
-  x.try_inverse().unwrap_or(G::ZERO)
+pub fn g_inverse_value<F: AiurField>(x: F) -> F {
+  // Total: the hint's contract is `0 ↦ 0` (the crate trait leaves
+  // `inverse(0)` implementation-defined, and the p3-backed fields panic).
+  if x.is_zero() { F::ZERO } else { x.inverse() }
+}
+
+/// The value of the `UnconstrainedGlDivMod` hint: the canonical integer
+/// split as `q·p_goldilocks + r`. Shared by the interpreter, the codegen'd
+/// kernels, and trace population.
+#[inline]
+pub fn gl_divmod_value<F: AiurField>(x: F) -> (F, F) {
+  x.gl_divmod()
+}
+
+/// The value of the `UnconstrainedGlInverse` hint: the inverse modulo
+/// p_goldilocks (`0 ↦ 0`). Shared like `g_inverse_value`.
+#[inline]
+pub fn gl_inverse_value<F: AiurField>(x: F) -> F {
+  x.gl_inverse()
 }
 
 /// Helper extracted for the codegen'd kernel: compute the unconstrained
 /// BigUint div-mod and return `(q_ptr, r_ptr)`. Same side effects on
 /// `record.memory_queries` as the inlined `Op::UnconstrainedBigUintDivMod`
 /// arm in the interpreter.
-pub fn unconstrained_big_uint_div_mod_helper(
-  a_ptr: G,
-  b_ptr: G,
-  record: &mut QueryRecord,
-) -> Result<(G, G), ExecError> {
+pub fn unconstrained_big_uint_div_mod_helper<F: AiurField>(
+  a_ptr: F,
+  b_ptr: F,
+  record: &mut QueryRecord<F>,
+) -> Result<(F, F), ExecError> {
   let a_limbs = read_klimbs_u64(&record.memory_queries, a_ptr)
     .map_err(ExecError::UnconstrainedBigUintDivModFailed)?;
   let b_limbs = read_klimbs_u64(&record.memory_queries, b_ptr)
@@ -934,11 +1003,11 @@ pub fn unconstrained_big_uint_div_mod_helper(
 /// population: recompute `(q, r)` and resolve the list-head pointers the
 /// execution already recorded in `memory[10]` — every node was built there
 /// during execution, so each key must be present.
-pub fn find_unconstrained_big_uint_div_mod(
-  a_ptr: G,
-  b_ptr: G,
-  memory: &FxIndexMap<usize, QueryMap>,
-) -> Result<(G, G), String> {
+pub fn find_unconstrained_big_uint_div_mod<F: AiurField>(
+  a_ptr: F,
+  b_ptr: F,
+  memory: &FxIndexMap<usize, QueryMap<F>>,
+) -> Result<(F, F), String> {
   let a_limbs = read_klimbs_u64(memory, a_ptr)?;
   let b_limbs = read_klimbs_u64(memory, b_ptr)?;
   let a_big = klimbs_u64_to_biguint(&a_limbs);
@@ -955,24 +1024,24 @@ pub fn find_unconstrained_big_uint_div_mod(
 
 /// Read-only twin of `build_klimbs_u64`: resolve the pointer of each
 /// (already-recorded) list node without inserting.
-fn find_klimbs_u64(
-  memory: &FxIndexMap<usize, QueryMap>,
+fn find_klimbs_u64<F: AiurField>(
+  memory: &FxIndexMap<usize, QueryMap<F>>,
   limbs: &[u64],
-) -> Result<G, String> {
+) -> Result<F, String> {
   let queries = memory.get(&10).ok_or_else(|| {
     "memory[10] channel not registered (no List<U64> in program?)".to_string()
   })?;
-  let nil_key: Vec<G> =
-    std::iter::once(G::ONE).chain((0..9).map(|_| G::ZERO)).collect();
+  let nil_key: Vec<F> =
+    std::iter::once(F::ONE).chain((0..9).map(|_| F::ZERO)).collect();
   let mut tail_ptr = queries
     .get(&nil_key)
     .ok_or_else(|| "List<U64> Nil node not recorded".to_string())?
     .output[0];
   for limb in limbs.iter().rev() {
-    let mut key: Vec<G> = Vec::with_capacity(10);
-    key.push(G::ZERO); // Cons tag (first variant of ListNode‹U64›)
+    let mut key: Vec<F> = Vec::with_capacity(10);
+    key.push(F::ZERO); // Cons tag (first variant of ListNode‹U64›)
     for b in &limb.to_le_bytes() {
-      key.push(G::from_u8(*b));
+      key.push(F::from_u8(*b));
     }
     key.push(tail_ptr);
     tail_ptr = queries
@@ -989,9 +1058,9 @@ fn find_klimbs_u64(
 /// u64 limbs in head-first order. Each memory[10] entry is the standard Aiur
 /// tagged-enum layout: `[tag, byte0..byte7, next_ptr]`. `tag == 0` = Nil
 /// (terminator), `tag == 1` = Cons. Bytes are LE within the u64.
-fn read_klimbs_u64(
-  memory: &FxIndexMap<usize, QueryMap>,
-  head_ptr: G,
+fn read_klimbs_u64<F: AiurField>(
+  memory: &FxIndexMap<usize, QueryMap<F>>,
+  head_ptr: F,
 ) -> Result<Vec<u64>, String> {
   let queries = memory.get(&10).ok_or_else(|| {
     "memory[10] channel not registered (no List<U64> in program?)".to_string()
@@ -1067,37 +1136,37 @@ fn biguint_to_klimbs_u64(n: &num_bigint::BigUint) -> Vec<u64> {
 /// (unconstrained); subsequent constrained `Load`s by the kernel will bump
 /// the multiplicity. Content-addressed via `QueryMap::get_mut`, so repeated
 /// identical sub-tails share storage.
-fn build_klimbs_u64(
-  memory: &mut FxIndexMap<usize, QueryMap>,
+fn build_klimbs_u64<F: AiurField>(
+  memory: &mut FxIndexMap<usize, QueryMap<F>>,
   limbs: &[u64],
-) -> Result<G, String> {
+) -> Result<F, String> {
   let queries = memory.get_mut(&10).ok_or_else(|| {
     "memory[10] channel not registered (no List<U64> in program?)".to_string()
   })?;
   // Find or insert the Nil ptr (tag = 1, padded payload all zero).
-  let nil_key: Vec<G> =
-    std::iter::once(G::ONE).chain((0..9).map(|_| G::ZERO)).collect();
+  let nil_key: Vec<F> =
+    std::iter::once(F::ONE).chain((0..9).map(|_| F::ZERO)).collect();
   let mut tail_ptr = if let Some(out) = queries.get_mut(&nil_key) {
     out.output[0]
   } else {
-    let ptr = G::from_usize(queries.len());
-    queries.insert(&nil_key, &[ptr], G::ZERO);
+    let ptr = F::from_usize(queries.len());
+    queries.insert(&nil_key, &[ptr], F::ZERO);
     ptr
   };
   // Walk limbs in REVERSE so each Cons points at the previously-built tail.
   for limb in limbs.iter().rev() {
     let bytes = limb.to_le_bytes();
-    let mut key: Vec<G> = Vec::with_capacity(10);
-    key.push(G::ZERO); // Cons tag (first variant of ListNode‹U64›)
+    let mut key: Vec<F> = Vec::with_capacity(10);
+    key.push(F::ZERO); // Cons tag (first variant of ListNode‹U64›)
     for b in &bytes {
-      key.push(G::from_u8(*b));
+      key.push(F::from_u8(*b));
     }
     key.push(tail_ptr);
     tail_ptr = if let Some(out) = queries.get_mut(&key) {
       out.output[0]
     } else {
-      let ptr = G::from_usize(queries.len());
-      queries.insert(&key, &[ptr], G::ZERO);
+      let ptr = F::from_usize(queries.len());
+      queries.insert(&key, &[ptr], F::ZERO);
       ptr
     };
   }
diff --git a/crates/aiur/src/gadgets.rs b/crates/aiur/src/gadgets.rs
index 8e556f7e..8cfd7db8 100644
--- a/crates/aiur/src/gadgets.rs
+++ b/crates/aiur/src/gadgets.rs
@@ -7,7 +7,7 @@ use multi_stark::{
   p3_matrix::dense::RowMajorMatrix,
 };
 
-use crate::{G, execute::QueryRecord};
+use crate::execute::QueryRecord;
 
 /// A trait representing a generic Aiur gadget.
 ///
@@ -18,7 +18,7 @@ use crate::{G, execute::QueryRecord};
 /// - How to execute its computation on concrete inputs.
 /// - Which symbolic lookups it requires during circuit synthesis.
 /// - How to provide witness data for the prover.
-pub(crate) trait AiurGadget {
+pub(crate) trait AiurGadget<F: Copy> {
   /// The type representing the gadget's operation.
   type Op;
 
@@ -29,18 +29,18 @@ pub(crate) trait AiurGadget {
   fn main_width(&self) -> usize;
 
   /// The gadget's preprocessed trace, if any.
-  fn preprocessed(&self) -> Option<RowMajorMatrix<G>>;
+  fn preprocessed(&self) -> Option<RowMajorMatrix<F>>;
 
   /// Executes the gadget on concrete inputs, returning the resulting output values.
   fn execute(
     &self,
     op: &Self::Op,
-    input: &[G],
-    record: &mut QueryRecord,
-  ) -> Vec<G>;
+    input: &[F],
+    record: &mut QueryRecord<F>,
+  ) -> Vec<F>;
 
   /// Returns the lookups associated with this gadget.
-  fn lookups(&self) -> Vec<Lookup<Expr<G>>>;
+  fn lookups(&self) -> Vec<Lookup<Expr<F>>>;
 
   /// Returns the witness data for the prover, including a row-major trace matrix and
   /// the flat lookup values.
@@ -50,7 +50,7 @@ pub(crate) trait AiurGadget {
   /// layout always matches the AIR.
   fn witness_data(
     &self,
-    record: &QueryRecord,
+    record: &QueryRecord<F>,
     slot_arg_widths: &[usize],
-  ) -> (RowMajorMatrix<G>, LookupValues<G>);
+  ) -> (RowMajorMatrix<F>, LookupValues<F>);
 }
diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs
index 667cb8ad..f47b686a 100644
--- a/crates/aiur/src/gadgets/bytes1.rs
+++ b/crates/aiur/src/gadgets/bytes1.rs
@@ -1,13 +1,12 @@
 use multi_stark::{
   expr::Expr,
   lookup::{Lookup, LookupValues},
-  p3_field::{PrimeCharacteristicRing, PrimeField64},
   p3_matrix::dense::RowMajorMatrix,
 };
 
 use crate::{
-  G, execute::QueryRecord, gadgets::AiurGadget, u8_bit_decomposition_channel,
-  u8_shift_left_channel, u8_shift_right_channel,
+  AiurField, G, execute::QueryRecord, gadgets::AiurGadget,
+  u8_bit_decomposition_channel, u8_shift_left_channel, u8_shift_right_channel,
 };
 
 /// Number of columns in the trace with multiplicities for
@@ -32,7 +31,7 @@ pub enum Bytes1Op {
   ShiftRight,
 }
 
-impl AiurGadget for Bytes1 {
+impl<F: AiurField> AiurGadget<F> for Bytes1 {
   type Op = Bytes1Op;
 
   fn output_size(&self, op: &Bytes1Op) -> usize {
@@ -47,11 +46,11 @@ impl AiurGadget for Bytes1 {
   }
 
   /// Builds the preprocessed trace over all 256 byte values.
-  fn preprocessed(&self) -> Option<RowMajorMatrix<G>> {
-    let mut values = vec![G::ZERO; 256 * PREPROCESSED_TRACE_WIDTH];
+  fn preprocessed(&self) -> Option<RowMajorMatrix<F>> {
+    let mut values = vec![F::ZERO; 256 * PREPROCESSED_TRACE_WIDTH];
     values.chunks_exact_mut(PREPROCESSED_TRACE_WIDTH).enumerate().for_each(
       |(i, row)| {
-        let byte = G::from_usize(i);
+        let byte = F::from_usize(i);
 
         // Raw byte value
         row[0] = byte;
@@ -76,9 +75,9 @@ impl AiurGadget for Bytes1 {
   fn execute(
     &self,
     op: &Bytes1Op,
-    input: &[G],
-    record: &mut QueryRecord,
-  ) -> Vec<G> {
+    input: &[F],
+    record: &mut QueryRecord<F>,
+  ) -> Vec<F> {
     let byte = &input[0];
     match op {
       Bytes1Op::BitDecomposition => {
@@ -96,7 +95,7 @@ impl AiurGadget for Bytes1 {
     }
   }
 
-  fn lookups(&self) -> Vec<Lookup<Expr<G>>> {
+  fn lookups(&self) -> Vec<Lookup<Expr<F>>> {
     // Channels
     let bit_decomposition_channel =
       Expr::constant(u8_bit_decomposition_channel());
@@ -153,10 +152,10 @@ impl AiurGadget for Bytes1 {
 
   fn witness_data(
     &self,
-    record: &QueryRecord,
+    record: &QueryRecord<F>,
     slot_arg_widths: &[usize],
-  ) -> (RowMajorMatrix<G>, LookupValues<G>) {
-    let mut rows = vec![G::ZERO; 256 * TRACE_WIDTH];
+  ) -> (RowMajorMatrix<F>, LookupValues<F>) {
+    let mut rows = vec![F::ZERO; 256 * TRACE_WIDTH];
 
     // There are `TRACE_WIDTH` lookups per row, one for each multiplicity.
     let mut builder = LookupValues::builder(256, slot_arg_widths);
@@ -173,7 +172,7 @@ impl AiurGadget for Bytes1 {
       .zip(&record.bytes1_queries.0)
       .zip(row_writers.iter_mut())
       .for_each(|(((byte, row), &[bd, shl, shr]), row_lookups)| {
-        let byte = G::from_usize(byte);
+        let byte = F::from_usize(byte);
         row[0] = bd;
         row[1] = shl;
         row[2] = shr;
@@ -204,46 +203,46 @@ impl AiurGadget for Bytes1 {
 }
 
 /// Accumulator of queries performed against `Bytes1`.
-pub struct Bytes1Queries([[G; TRACE_WIDTH]; 256]);
+pub struct Bytes1Queries<F = G>([[F; TRACE_WIDTH]; 256]);
 
-impl Bytes1Queries {
+impl<F: AiurField> Bytes1Queries<F> {
   #[inline]
   pub(crate) fn new() -> Self {
-    Self([[G::ZERO; TRACE_WIDTH]; 256])
+    Self([[F::ZERO; TRACE_WIDTH]; 256])
   }
 
-  pub(crate) fn bump_bit_decomposition(&mut self, byte: &G) {
+  pub(crate) fn bump_bit_decomposition(&mut self, byte: &F) {
     self.bump_multiplicity_for(byte, 0)
   }
 
-  pub(crate) fn bump_shift_left(&mut self, byte: &G) {
+  pub(crate) fn bump_shift_left(&mut self, byte: &F) {
     self.bump_multiplicity_for(byte, 1)
   }
 
-  pub(crate) fn bump_shift_right(&mut self, byte: &G) {
+  pub(crate) fn bump_shift_right(&mut self, byte: &F) {
     self.bump_multiplicity_for(byte, 2)
   }
 
-  pub(crate) fn bump_multiplicity_for(&mut self, byte: &G, col: usize) {
+  pub(crate) fn bump_multiplicity_for(&mut self, byte: &F, col: usize) {
     let row = usize::try_from(byte.as_canonical_u64()).unwrap();
-    self.0[row][col] += G::ONE;
+    self.0[row][col] += F::ONE;
   }
 }
 
 impl Bytes1 {
   #[inline]
-  pub fn bit_decompose(byte: &G) -> Vec<G> {
+  pub fn bit_decompose<F: AiurField>(byte: &F) -> Vec<F> {
     let byte_u64 = byte.as_canonical_u64();
-    (0..8).map(|i| G::from_bool((byte_u64 >> i) & 1 == 1)).collect()
+    (0..8).map(|i| F::from_bool((byte_u64 >> i) & 1 == 1)).collect()
   }
 
   #[inline]
-  pub fn shift_left(byte: &G) -> G {
-    G::from_u64((byte.as_canonical_u64() << 1) & 255)
+  pub fn shift_left<F: AiurField>(byte: &F) -> F {
+    F::from_u64((byte.as_canonical_u64() << 1) & 255)
   }
 
   #[inline]
-  pub fn shift_right(byte: &G) -> G {
-    G::from_u64(byte.as_canonical_u64() >> 1)
+  pub fn shift_right<F: AiurField>(byte: &F) -> F {
+    F::from_u64(byte.as_canonical_u64() >> 1)
   }
 }
diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs
index 8a2e16ef..2c951b7f 100644
--- a/crates/aiur/src/gadgets/bytes2.rs
+++ b/crates/aiur/src/gadgets/bytes2.rs
@@ -1,14 +1,14 @@
 use multi_stark::{
   expr::Expr,
   lookup::{Lookup, LookupValues},
-  p3_field::{PrimeCharacteristicRing, PrimeField64},
   p3_matrix::dense::RowMajorMatrix,
 };
 
 use crate::{
-  G, execute::QueryRecord, gadgets::AiurGadget, u8_add_channel, u8_and_channel,
-  u8_less_than_channel, u8_mul_channel, u8_or_channel, u8_range_check_channel,
-  u8_sub_channel, u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel,
+  AiurField, G, execute::QueryRecord, gadgets::AiurGadget, u8_add_channel,
+  u8_and_channel, u8_less_than_channel, u8_mul_channel, u8_or_channel,
+  u8_range_check_channel, u8_sub_channel, u8_xor_channel,
+  u8_xor_split4_channel, u8_xor_split7_channel,
 };
 
 /// Number of columns in the trace with multiplicities for
@@ -56,7 +56,7 @@ pub enum Bytes2Op {
   XorSplit4,
 }
 
-impl AiurGadget for Bytes2 {
+impl<F: AiurField> AiurGadget<F> for Bytes2 {
   type Op = Bytes2Op;
 
   fn output_size(&self, op: &Bytes2Op) -> usize {
@@ -76,42 +76,42 @@ impl AiurGadget for Bytes2 {
   }
 
   /// Builds the preprocessed trace over all 256 byte values.
-  fn preprocessed(&self) -> Option<RowMajorMatrix<G>> {
+  fn preprocessed(&self) -> Option<RowMajorMatrix<F>> {
     let mut trace_values =
       Vec::with_capacity(256 * 256 * PREPROCESSED_TRACE_WIDTH);
     for i in 0..=u8::MAX {
       for j in 0..=u8::MAX {
         // Raw bytes
-        trace_values.push(G::from_u8(i));
-        trace_values.push(G::from_u8(j));
+        trace_values.push(F::from_u8(i));
+        trace_values.push(F::from_u8(j));
 
         // Xor
-        trace_values.push(G::from_u8(i ^ j));
+        trace_values.push(F::from_u8(i ^ j));
 
         // Add low byte (carry derived in-circuit, no column)
-        trace_values.push(G::from_u8(i.wrapping_add(j)));
+        trace_values.push(F::from_u8(i.wrapping_add(j)));
 
         // Sub low byte (borrow derived in-circuit, no column)
-        trace_values.push(G::from_u8(i.wrapping_sub(j)));
+        trace_values.push(F::from_u8(i.wrapping_sub(j)));
 
         // And
-        trace_values.push(G::from_u8(i & j));
+        trace_values.push(F::from_u8(i & j));
 
         // Or
-        trace_values.push(G::from_u8(i | j));
+        trace_values.push(F::from_u8(i | j));
 
         // Less than
-        trace_values.push(G::from_bool(i < j));
+        trace_values.push(F::from_bool(i < j));
 
         // Mul (low byte, high byte)
         let p = u16::from(i) * u16::from(j);
-        trace_values.push(G::from_u8((p & 0xff) as u8));
-        trace_values.push(G::from_u8((p >> 8) as u8));
+        trace_values.push(F::from_u8((p & 0xff) as u8));
+        trace_values.push(F::from_u8((p >> 8) as u8));
 
         let (hi, lo) = Self::xor_split7_u8(i, j);
-        trace_values.extend([G::from_u8(hi), G::from_u8(lo)]);
+        trace_values.extend([F::from_u8(hi), F::from_u8(lo)]);
         let (hi, lo) = Self::xor_split4_u8(i, j);
-        trace_values.extend([G::from_u8(hi), G::from_u8(lo)]);
+        trace_values.extend([F::from_u8(hi), F::from_u8(lo)]);
       }
     }
     Some(RowMajorMatrix::new(trace_values, PREPROCESSED_TRACE_WIDTH))
@@ -120,9 +120,9 @@ impl AiurGadget for Bytes2 {
   fn execute(
     &self,
     op: &Bytes2Op,
-    input: &[G],
-    record: &mut QueryRecord,
-  ) -> Vec<G> {
+    input: &[F],
+    record: &mut QueryRecord<F>,
+  ) -> Vec<F> {
     let i = &input[0];
     let j = &input[1];
     match op {
@@ -170,7 +170,7 @@ impl AiurGadget for Bytes2 {
     }
   }
 
-  fn lookups(&self) -> Vec<Lookup<Expr<G>>> {
+  fn lookups(&self) -> Vec<Lookup<Expr<F>>> {
     // Channels
     let xor_channel = Expr::constant(u8_xor_channel());
     let add_channel = Expr::constant(u8_add_channel());
@@ -283,10 +283,10 @@ impl AiurGadget for Bytes2 {
 
   fn witness_data(
     &self,
-    record: &QueryRecord,
+    record: &QueryRecord<F>,
     slot_arg_widths: &[usize],
-  ) -> (RowMajorMatrix<G>, LookupValues<G>) {
-    let mut rows = vec![G::ZERO; 256 * 256 * TRACE_WIDTH];
+  ) -> (RowMajorMatrix<F>, LookupValues<F>) {
+    let mut rows = vec![F::ZERO; 256 * 256 * TRACE_WIDTH];
 
     // There are `TRACE_WIDTH` lookups per row, one for each multiplicity.
     let mut builder = LookupValues::builder(256 * 256, slot_arg_widths);
@@ -327,8 +327,8 @@ impl AiurGadget for Bytes2 {
           ),
           row_lookups,
         )| {
-          let i = G::from_usize(row_idx / 256);
-          let j = G::from_usize(row_idx % 256);
+          let i = F::from_usize(row_idx / 256);
+          let j = F::from_usize(row_idx % 256);
 
           row[0] = xor;
           row[1] = add;
@@ -386,114 +386,114 @@ impl AiurGadget for Bytes2 {
 }
 
 /// Accumulator of queries performed against `Bytes2`.
-pub struct Bytes2Queries(Box<[[G; TRACE_WIDTH]]>);
+pub struct Bytes2Queries<F = G>(Box<[[F; TRACE_WIDTH]]>);
 
-impl Bytes2Queries {
+impl<F: AiurField> Bytes2Queries<F> {
   #[inline]
   pub(crate) fn new() -> Self {
-    Self(vec![[G::ZERO; TRACE_WIDTH]; 256 * 256].into_boxed_slice())
+    Self(vec![[F::ZERO; TRACE_WIDTH]; 256 * 256].into_boxed_slice())
   }
 
-  pub(crate) fn bump_xor(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_xor(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 0)
   }
 
-  pub(crate) fn bump_add(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_add(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 1)
   }
 
-  pub(crate) fn bump_sub(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_sub(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 2)
   }
 
-  pub(crate) fn bump_and(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_and(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 3)
   }
 
-  pub(crate) fn bump_or(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_or(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 4)
   }
 
-  pub(crate) fn bump_less_than(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_less_than(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 5)
   }
 
-  pub fn bump_range_check(&mut self, i: &G, j: &G) {
+  pub fn bump_range_check(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 6)
   }
 
-  pub(crate) fn bump_mul(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_mul(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 7)
   }
 
-  pub(crate) fn bump_xor_split7(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_xor_split7(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 8)
   }
 
-  pub(crate) fn bump_xor_split4(&mut self, i: &G, j: &G) {
+  pub(crate) fn bump_xor_split4(&mut self, i: &F, j: &F) {
     self.bump_multiplicity_for(i, j, 9)
   }
 
-  pub(crate) fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) {
+  pub(crate) fn bump_multiplicity_for(&mut self, i: &F, j: &F, col: usize) {
     let i = usize::try_from(i.as_canonical_u64()).unwrap();
     let j = usize::try_from(j.as_canonical_u64()).unwrap();
     let row = 256 * i + j;
-    self.0[row][col] += G::ONE;
+    self.0[row][col] += F::ONE;
   }
 }
 
 impl Bytes2 {
   #[inline]
-  pub fn xor(i: &G, j: &G) -> G {
+  pub fn xor<F: AiurField>(i: &F, j: &F) -> F {
     let i: u8 = i.as_canonical_u64().try_into().unwrap();
     let j: u8 = j.as_canonical_u64().try_into().unwrap();
-    G::from_u8(i ^ j)
+    F::from_u8(i ^ j)
   }
 
   #[inline]
-  pub fn add(i: &G, j: &G) -> (G, G) {
+  pub fn add<F: AiurField>(i: &F, j: &F) -> (F, F) {
     let i: u8 = i.as_canonical_u64().try_into().unwrap();
     let j: u8 = j.as_canonical_u64().try_into().unwrap();
     let (r, o) = i.overflowing_add(j);
-    (G::from_u8(r), G::from_bool(o))
+    (F::from_u8(r), F::from_bool(o))
   }
 
   #[inline]
-  pub fn and(i: &G, j: &G) -> G {
+  pub fn and<F: AiurField>(i: &F, j: &F) -> F {
     let i: u8 = i.as_canonical_u64().try_into().unwrap();
     let j: u8 = j.as_canonical_u64().try_into().unwrap();
-    G::from_u8(i & j)
+    F::from_u8(i & j)
   }
 
   #[inline]
-  pub fn or(i: &G, j: &G) -> G {
+  pub fn or<F: AiurField>(i: &F, j: &F) -> F {
     let i: u8 = i.as_canonical_u64().try_into().unwrap();
     let j: u8 = j.as_canonical_u64().try_into().unwrap();
-    G::from_u8(i | j)
+    F::from_u8(i | j)
   }
 
   #[inline]
-  pub fn sub(i: &G, j: &G) -> (G, G) {
+  pub fn sub<F: AiurField>(i: &F, j: &F) -> (F, F) {
     let i: u8 = i.as_canonical_u64().try_into().unwrap();
     let j: u8 = j.as_canonical_u64().try_into().unwrap();
     let (r, u) = i.overflowing_sub(j);
-    (G::from_u8(r), G::from_bool(u))
+    (F::from_u8(r), F::from_bool(u))
   }
 
   #[inline]
-  pub fn less_than(i: &G, j: &G) -> G {
+  pub fn less_than<F: AiurField>(i: &F, j: &F) -> F {
     let i: u8 = i.as_canonical_u64().try_into().unwrap();
     let j: u8 = j.as_canonical_u64().try_into().unwrap();
-    G::from_bool(i < j)
+    F::from_bool(i < j)
   }
 
   /// `u8 * u8 -> (low byte, high byte)`. The product fits in 16 bits.
   #[inline]
-  pub fn mul(i: &G, j: &G) -> (G, G) {
+  pub fn mul<F: AiurField>(i: &F, j: &F) -> (F, F) {
     let i: u8 = i.as_canonical_u64().try_into().unwrap();
     let j: u8 = j.as_canonical_u64().try_into().unwrap();
     let p = u16::from(i) * u16::from(j);
-    (G::from_u8((p & 0xff) as u8), G::from_u8((p >> 8) as u8))
+    (F::from_u8((p & 0xff) as u8), F::from_u8((p >> 8) as u8))
   }
 
   /// Building block for a right-rotation by 7 bits over little-endian bytes:
@@ -513,20 +513,20 @@ impl Bytes2 {
   }
 
   #[inline]
-  pub fn xor_split7(i: &G, j: &G) -> (G, G) {
+  pub fn xor_split7<F: AiurField>(i: &F, j: &F) -> (F, F) {
     let (hi, lo) = Self::xor_split7_u8(
       u8::try_from(i.as_canonical_u64()).expect("byte-table input"),
       u8::try_from(j.as_canonical_u64()).expect("byte-table input"),
     );
-    (G::from_u8(hi), G::from_u8(lo))
+    (F::from_u8(hi), F::from_u8(lo))
   }
 
   #[inline]
-  pub fn xor_split4(i: &G, j: &G) -> (G, G) {
+  pub fn xor_split4<F: AiurField>(i: &F, j: &F) -> (F, F) {
     let (hi, lo) = Self::xor_split4_u8(
       u8::try_from(i.as_canonical_u64()).expect("byte-table input"),
       u8::try_from(j.as_canonical_u64()).expect("byte-table input"),
     );
-    (G::from_u8(hi), G::from_u8(lo))
+    (F::from_u8(hi), F::from_u8(lo))
   }
 }
diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs
index 3acf6666..79e3a3f8 100644
--- a/crates/aiur/src/lib.rs
+++ b/crates/aiur/src/lib.rs
@@ -9,83 +9,161 @@ pub mod trace;
 pub mod vk_codec;
 
 use indexmap::IndexMap;
-use multi_stark::p3_field::PrimeCharacteristicRing;
+use multi_stark::p3_field::PrimeField64;
+use multi_stark::traits::{Algebra, Field, TwoAdicField};
 use rustc_hash::FxBuildHasher;
 
+/// The default (and currently only proving-ready) Aiur field.
 pub type G = multi_stark::p3_goldilocks::Goldilocks;
 pub type FxIndexMap<K, V> = IndexMap<K, V, FxBuildHasher>;
 
+/// The field surface Aiur needs beyond multi-stark's crate traits:
+/// canonical integer extraction. The executor and witness builders only
+/// ever call it on values that are small by construction (bytes,
+/// pointers, counters, u32 words) or on the deliberate 8-byte hint
+/// decomposition (`UnconstrainedGToBytes`), so implementations for
+/// fields larger than 64 bits may take the canonical value's low 64
+/// bits — with the caveat that such a field's toplevels must not use
+/// the 8-byte hint (the foreign Goldilocks interface doesn't).
+pub trait AiurField: Field + TwoAdicField + Ord + std::fmt::Display {
+  /// The canonical value as a `u64`; exact for values < 2^64.
+  fn as_canonical_u64(&self) -> u64;
+  /// The `UnconstrainedGlDivMod` hint: the canonical integer value split
+  /// as `q · p_goldilocks + r` with `r < p_goldilocks`, both returned as
+  /// field values. Over Goldilocks itself every value is `< p`, so this
+  /// is `(0, v)`; over a large field it is exact big-integer division.
+  fn gl_divmod(&self) -> (Self, Self);
+  /// The `UnconstrainedGlInverse` hint: the inverse MODULO p_goldilocks of
+  /// a canonical value `< p_goldilocks` (`0 ↦ 0`), as a field value.
+  fn gl_inverse(&self) -> Self;
+}
+
+/// The Goldilocks modulus, the inner field of the recursive verifier.
+pub const GOLDILOCKS_P: u64 = 0xFFFF_FFFF_0000_0001;
+
+impl AiurField for G {
+  #[inline]
+  fn as_canonical_u64(&self) -> u64 {
+    <Self as PrimeField64>::as_canonical_u64(self)
+  }
+  #[inline]
+  fn gl_divmod(&self) -> (Self, Self) {
+    (<Self as Algebra<Self>>::ZERO, *self)
+  }
+  #[inline]
+  fn gl_inverse(&self) -> Self {
+    if self.is_zero() { <Self as Algebra<Self>>::ZERO } else { self.inverse() }
+  }
+}
+
+/// The BLS12-381 scalar field as an Aiur field (the KZG terminal
+/// stage). `as_canonical_u64` takes the canonical value's low 64 bits —
+/// exact for the bytes/pointers/counters Aiur extracts; toplevels for
+/// this field must not use the 8-byte hint (see the trait docs).
+#[cfg(feature = "kzg")]
+impl AiurField for multi_stark::ark_adapter::Scalar {
+  #[inline]
+  fn as_canonical_u64(&self) -> u64 {
+    self.canonical_low_u64()
+  }
+  fn gl_divmod(&self) -> (Self, Self) {
+    use multi_stark::ark_adapter::Scalar;
+    // Long division of the canonical 256-bit value by the 64-bit modulus,
+    // most significant limb first; the quotient is < the scalar modulus
+    // (it is < v), so it embeds exactly.
+    let limbs = self.canonical_limbs_le();
+    let mut q = [0u64; 4];
+    let mut rem: u128 = 0;
+    for i in (0..4).rev() {
+      let cur = (rem << 64) | u128::from(limbs[i]);
+      q[i] = u64::try_from(cur / u128::from(GOLDILOCKS_P))
+        .expect("limb quotient fits");
+      rem = cur % u128::from(GOLDILOCKS_P);
+    }
+    (
+      Scalar::from_limbs_le(q),
+      Self::from_u64(u64::try_from(rem).expect("remainder < p")),
+    )
+  }
+  fn gl_inverse(&self) -> Self {
+    let v = <G as Field>::from_u64(self.canonical_low_u64());
+    <Self as Field>::from_u64(AiurField::as_canonical_u64(
+      &AiurField::gl_inverse(&v),
+    ))
+  }
+}
+
 #[inline]
-pub const fn function_channel() -> G {
-  G::ZERO
+pub fn function_channel<F: AiurField>() -> F {
+  <F as Algebra<F>>::ZERO
 }
 
 #[inline]
-pub const fn memory_channel() -> G {
-  G::ONE
+pub fn memory_channel<F: AiurField>() -> F {
+  <F as Algebra<F>>::ONE
 }
 
 #[inline]
-pub const fn u8_bit_decomposition_channel() -> G {
-  G::TWO
+pub fn u8_bit_decomposition_channel<F: AiurField>() -> F {
+  F::from_u8(2)
 }
 
 #[inline]
-pub fn u8_shift_left_channel() -> G {
-  G::from_u8(3)
+pub fn u8_shift_left_channel<F: AiurField>() -> F {
+  F::from_u8(3)
 }
 
 #[inline]
-pub fn u8_shift_right_channel() -> G {
-  G::from_u8(4)
+pub fn u8_shift_right_channel<F: AiurField>() -> F {
+  F::from_u8(4)
 }
 
 #[inline]
-pub fn u8_xor_channel() -> G {
-  G::from_u8(5)
+pub fn u8_xor_channel<F: AiurField>() -> F {
+  F::from_u8(5)
 }
 
 #[inline]
-pub fn u8_add_channel() -> G {
-  G::from_u8(6)
+pub fn u8_add_channel<F: AiurField>() -> F {
+  F::from_u8(6)
 }
 
 #[inline]
-pub fn u8_sub_channel() -> G {
-  G::from_u8(7)
+pub fn u8_sub_channel<F: AiurField>() -> F {
+  F::from_u8(7)
 }
 
 #[inline]
-pub fn u8_and_channel() -> G {
-  G::from_u8(8)
+pub fn u8_and_channel<F: AiurField>() -> F {
+  F::from_u8(8)
 }
 
 #[inline]
-pub fn u8_or_channel() -> G {
-  G::from_u8(9)
+pub fn u8_or_channel<F: AiurField>() -> F {
+  F::from_u8(9)
 }
 
 #[inline]
-pub fn u8_less_than_channel() -> G {
-  G::from_u8(10)
+pub fn u8_less_than_channel<F: AiurField>() -> F {
+  F::from_u8(10)
 }
 
 #[inline]
-pub fn u8_range_check_channel() -> G {
-  G::from_u8(11)
+pub fn u8_range_check_channel<F: AiurField>() -> F {
+  F::from_u8(11)
 }
 
 #[inline]
-pub fn u8_mul_channel() -> G {
-  G::from_u8(12)
+pub fn u8_mul_channel<F: AiurField>() -> F {
+  F::from_u8(12)
 }
 
 #[inline]
-pub fn u8_xor_split7_channel() -> G {
-  G::from_u8(13)
+pub fn u8_xor_split7_channel<F: AiurField>() -> F {
+  F::from_u8(13)
 }
 
 #[inline]
-pub fn u8_xor_split4_channel() -> G {
-  G::from_u8(14)
+pub fn u8_xor_split4_channel<F: AiurField>() -> F {
+  F::from_u8(14)
 }
diff --git a/crates/aiur/src/memory.rs b/crates/aiur/src/memory.rs
index c3fd487d..42493368 100644
--- a/crates/aiur/src/memory.rs
+++ b/crates/aiur/src/memory.rs
@@ -1,7 +1,6 @@
 use multi_stark::{
   expr::Expr,
   lookup::{Lookup, LookupValues},
-  p3_field::PrimeCharacteristicRing,
   p3_matrix::dense::RowMajorMatrix,
 };
 use rayon::{
@@ -11,14 +10,18 @@ use rayon::{
   slice::ParallelSliceMut,
 };
 
-use crate::{G, execute::QueryRecord, memory_channel};
+use crate::{AiurField, execute::QueryRecord, memory_channel};
 
 pub struct Memory {
   pub(crate) width: usize,
 }
 
 impl Memory {
-  pub(super) fn lookup_args(size: G, ptr: G, values: &[G]) -> Vec<G> {
+  pub(super) fn lookup_args<F: AiurField>(
+    size: F,
+    ptr: F,
+    values: &[F],
+  ) -> Vec<F> {
     let mut args = Vec::with_capacity(3 + values.len());
     args.extend([memory_channel(), size, ptr]);
     args.extend(values);
@@ -32,13 +35,15 @@ impl Memory {
 
   /// Returns the memory circuit together with its base-field constraints and
   /// its (single) lookup.
-  pub fn build(size: usize) -> (Self, Vec<Expr<G>>, Vec<Lookup<Expr<G>>>) {
+  pub fn build<F: AiurField>(
+    size: usize,
+  ) -> (Self, Vec<Expr<F>>, Vec<Lookup<Expr<F>>>) {
     let multiplicity = Expr::main(0);
     let selector = Expr::main(1);
     let pointer = Expr::main(2);
     let mut args = Vec::with_capacity(3 + size);
     args.push(selector.clone() * Expr::constant(memory_channel()));
-    args.push(selector.clone() * Expr::constant(G::from_usize(size)));
+    args.push(selector.clone() * Expr::constant(F::from_usize(size)));
     args.push(selector.clone() * pointer);
     for val_idx in 0..size {
       let col = u32::try_from(3 + val_idx).expect("column index exceeds u32");
@@ -55,7 +60,7 @@ impl Memory {
     let is_real_next = Expr::main_next(1);
     let ptr = Expr::main(2);
     let ptr_next = Expr::main_next(2);
-    let one = || Expr::constant(G::ONE);
+    let one = || Expr::constant(F::ONE);
     let is_real_transition = is_real_next * Expr::IsTransition;
     let constraints = vec![
       is_real.clone() * (is_real.clone() - one()),
@@ -66,11 +71,11 @@ impl Memory {
     (Self { width }, constraints, lookups)
   }
 
-  pub fn witness_data(
+  pub fn witness_data<F: AiurField>(
     size: usize,
-    record: &QueryRecord,
+    record: &QueryRecord<F>,
     slot_arg_widths: &[usize],
-  ) -> (RowMajorMatrix<G>, LookupValues<G>) {
+  ) -> (RowMajorMatrix<F>, LookupValues<F>) {
     let queries = record.memory_queries.get(&size).expect("Invalid size");
     let width = Self::width(size);
     let height_no_padding = queries.len();
@@ -82,7 +87,7 @@ impl Memory {
       height_no_padding.next_power_of_two()
     };
 
-    let mut rows = vec![G::ZERO; height * width];
+    let mut rows = vec![F::ZERO; height * width];
     let rows_no_padding = &mut rows[0..height_no_padding * width];
 
     // Builder rows start zeroed (`Lookup::empty()`), so padding rows need no
@@ -97,11 +102,11 @@ impl Memory {
       .for_each(|(i, (row, row_lookups))| {
         let (values, result) = queries.get_index(i).expect("index in range");
         row[0] = result.multiplicity;
-        row[1] = G::ONE;
-        row[2] = G::from_usize(i);
+        row[1] = F::ONE;
+        row[2] = F::from_usize(i);
         row[3..].copy_from_slice(values);
 
-        let args = Self::lookup_args(G::from_usize(size), row[2], &row[3..]);
+        let args = Self::lookup_args(F::from_usize(size), row[2], &row[3..]);
         row_lookups.pull(0, row[0], &args);
       });
     drop(row_writers);
diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs
index 56f97306..10885f98 100644
--- a/crates/aiur/src/querymap.rs
+++ b/crates/aiur/src/querymap.rs
@@ -1,22 +1,20 @@
-use multi_stark::p3_field::PrimeField64;
-
-use crate::G;
+use crate::{AiurField, G};
 
 /// Immutable view of one query entry.
 #[derive(Clone, Copy)]
-pub struct QueryRef<'a> {
-  pub(crate) output: &'a [G],
-  pub multiplicity: G,
+pub struct QueryRef<'a, F = G> {
+  pub(crate) output: &'a [F],
+  pub multiplicity: F,
 }
 
 /// Mutable view of one query entry: the output is fixed at insertion,
 /// only the multiplicity is bumped on memo hits.
-pub struct QueryRefMut<'a> {
-  pub output: &'a [G],
-  pub multiplicity: &'a mut G,
+pub struct QueryRefMut<'a, F = G> {
+  pub output: &'a [F],
+  pub multiplicity: &'a mut F,
 }
 
-fn hash_g_slice(key: &[G]) -> u64 {
+fn hash_g_slice<F: AiurField>(key: &[F]) -> u64 {
   use std::hash::Hasher;
   let mut h = rustc_hash::FxHasher::default();
   for g in key {
@@ -146,22 +144,22 @@ impl<T: Copy> Drop for HugeVec<T> {
   }
 }
 
-/// Append-only segmented arena of fixed-stride `G` entries. Entry `i` lives
-/// at segment `i >> SEG_BITS`, offset `(i & SEG_MASK) * stride` — no entry
-/// ever straddles a segment.
-struct SegStore {
+/// Append-only segmented arena of fixed-stride field entries. Entry `i`
+/// lives at segment `i >> SEG_BITS`, offset `(i & SEG_MASK) * stride` — no
+/// entry ever straddles a segment.
+struct SegStore<F: Copy> {
   stride: usize,
-  segs: Vec<HugeVec<G>>,
+  segs: Vec<HugeVec<F>>,
   entries: usize,
 }
 
-impl SegStore {
+impl<F: AiurField> SegStore<F> {
   fn new(stride: usize) -> Self {
     Self { stride, segs: Vec::new(), entries: 0 }
   }
 
   #[inline]
-  fn at(&self, i: usize) -> &[G] {
+  fn at(&self, i: usize) -> &[F] {
     if self.stride == 0 {
       return &[];
     }
@@ -170,7 +168,7 @@ impl SegStore {
   }
 
   #[inline]
-  fn at_mut(&mut self, i: usize) -> &mut [G] {
+  fn at_mut(&mut self, i: usize) -> &mut [F] {
     if self.stride == 0 {
       return &mut [];
     }
@@ -179,7 +177,7 @@ impl SegStore {
   }
 
   #[inline]
-  fn push(&mut self, vals: &[G]) {
+  fn push(&mut self, vals: &[F]) {
     debug_assert_eq!(vals.len(), self.stride);
     if self.stride != 0 {
       let seg = self.entries >> SEG_BITS;
@@ -243,18 +241,18 @@ impl SegHashes {
 ///
 /// Entry index == insertion order; memory circuits use it as the pointer
 /// value, mirroring the old `IndexMap::get_index_of` semantics.
-pub struct QueryMap {
+pub struct QueryMap<F: Copy = G> {
   /// Output width; inferred on first insert (not statically available in
   /// `FunctionLayout`).
   out_stride_set: bool,
-  keys: SegStore,
-  outs: SegStore,
-  mults: SegStore,
+  keys: SegStore<F>,
+  outs: SegStore<F>,
+  mults: SegStore<F>,
   hashes: SegHashes,
   table: hashbrown::HashTable<u32>,
 }
 
-impl QueryMap {
+impl<F: AiurField> QueryMap<F> {
   pub fn new(key_stride: usize) -> Self {
     Self {
       out_stride_set: false,
@@ -282,7 +280,7 @@ impl QueryMap {
     self.keys.retained_elems() + self.outs.retained_elems()
   }
 
-  pub fn get_index_of(&self, key: &[G]) -> Option<usize> {
+  pub fn get_index_of(&self, key: &[F]) -> Option<usize> {
     debug_assert_eq!(key.len(), self.keys.stride);
     let hash = hash_g_slice(key);
     self
@@ -291,7 +289,7 @@ impl QueryMap {
       .map(|&i| i as usize)
   }
 
-  pub fn get(&self, key: &[G]) -> Option<QueryRef<'_>> {
+  pub fn get(&self, key: &[F]) -> Option<QueryRef<'_, F>> {
     let i = self.get_index_of(key)?;
     Some(QueryRef {
       output: self.outs.at(i),
@@ -299,7 +297,7 @@ impl QueryMap {
     })
   }
 
-  pub fn get_mut(&mut self, key: &[G]) -> Option<QueryRefMut<'_>> {
+  pub fn get_mut(&mut self, key: &[F]) -> Option<QueryRefMut<'_, F>> {
     let i = self.get_index_of(key)?;
     Some(QueryRefMut {
       output: self.outs.at(i),
@@ -310,7 +308,7 @@ impl QueryMap {
   /// Append a new entry. The key must not already be present: call sites
   /// only insert on a confirmed miss, and a same-key re-entrant call
   /// would loop forever before reaching its own insert.
-  pub fn insert(&mut self, key: &[G], output: &[G], multiplicity: G) {
+  pub fn insert(&mut self, key: &[F], output: &[F], multiplicity: F) {
     debug_assert_eq!(key.len(), self.keys.stride);
     debug_assert!(self.get_index_of(key).is_none());
     if !self.out_stride_set {
@@ -331,14 +329,14 @@ impl QueryMap {
 
   /// Entry at insertion index `i`: the key slice plus a mutable handle on
   /// the multiplicity (memory `Load` bumps the pointed-to row's count).
-  pub fn get_index_mut(&mut self, i: usize) -> Option<(&[G], &mut G)> {
+  pub fn get_index_mut(&mut self, i: usize) -> Option<(&[F], &mut F)> {
     if i >= self.mults.entries {
       return None;
     }
     Some((self.keys.at(i), &mut self.mults.at_mut(i)[0]))
   }
 
-  pub fn get_index(&self, i: usize) -> Option<(&[G], QueryRef<'_>)> {
+  pub fn get_index(&self, i: usize) -> Option<(&[F], QueryRef<'_, F>)> {
     if i >= self.len() {
       return None;
     }
@@ -348,7 +346,7 @@ impl QueryMap {
     ))
   }
 
-  pub fn iter(&self) -> impl Iterator<Item = (&[G], QueryRef<'_>)> {
+  pub fn iter(&self) -> impl Iterator<Item = (&[F], QueryRef<'_, F>)> {
     (0..self.len()).map(|i| {
       (
         self.keys.at(i),
diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs
index 6cbbcc62..905443b3 100644
--- a/crates/aiur/src/synthesis.rs
+++ b/crates/aiur/src/synthesis.rs
@@ -1,13 +1,13 @@
 use multi_stark::{
+  config::PcsError,
+  config::{ProofConfig, Val},
   expr::Expr,
   lookup::Lookup,
-  p3_field::PrimeCharacteristicRing,
   p3_matrix::dense::RowMajorMatrix,
   prover::Proof,
   system::{CircuitInputs, ProverKey, System, SystemWitness},
-  types::{
-    CommitmentParameters, FriParameters, GoldilocksBlake3Config, PcsError,
-  },
+  traits::Field,
+  types::{CommitmentParameters, FriParameters, GoldilocksBlake3Config},
   verifier::VerificationError,
 };
 use rayon::iter::{
@@ -15,7 +15,7 @@ use rayon::iter::{
 };
 
 use crate::{
-  G,
+  AiurField,
   bytecode::{FunIdx, Toplevel},
   execute::{ExecError, IOBuffer, QueryRecord},
   function_channel,
@@ -28,15 +28,11 @@ pub type AiurConfig = GoldilocksBlake3Config;
 /// A proof under [`AiurConfig`].
 pub type AiurProof = Proof<AiurConfig>;
 
-pub struct AiurSystem {
-  toplevel: Toplevel,
+pub struct AiurSystem<SC: ProofConfig = AiurConfig> {
+  toplevel: Toplevel<Val<SC>>,
   // perhaps remove the key from the system in verifier only mode?
-  key: ProverKey<AiurConfig>,
-  /// The parameters the system's config was built from, kept for the
-  /// verifying-key codec (the config itself doesn't expose them back).
-  pub(crate) commitment_parameters: CommitmentParameters,
-  pub(crate) fri_parameters: FriParameters,
-  pub(crate) system: System<AiurConfig>,
+  key: ProverKey<SC>,
+  pub(crate) system: System<SC>,
   /// Per-circuit lookup-slot argument widths (in system order), retained so
   /// the witness builder can size its `LookupValues` without reading them
   /// back off the (now AIR-free) compiled circuits.
@@ -63,20 +59,22 @@ pub struct CircuitShape {
   pub preprocessed_height: usize,
 }
 
-impl AiurSystem {
-  pub fn build(
-    toplevel: Toplevel,
-    commitment_parameters: CommitmentParameters,
-    fri_parameters: FriParameters,
-  ) -> Self {
-    let mut circuit_inputs: Vec<CircuitInputs<G>> = Vec::new();
+/// The circuit list of a toplevel, in system order (constrained functions
+/// ascending, memories, `Bytes1`, `Bytes2`), plus the per-circuit lookup
+/// slot widths. Field-generic: the same bytecode synthesizes over any
+/// [`AiurField`].
+fn build_circuit_inputs<F: AiurField>(
+  toplevel: &Toplevel<F>,
+) -> (Vec<CircuitInputs<F>>, Vec<Vec<usize>>) {
+  {
+    let mut circuit_inputs: Vec<CircuitInputs<F>> = Vec::new();
     let mut slot_widths: Vec<Vec<usize>> = Vec::new();
 
     let mut push_circuit =
       |main_width: usize,
-       preprocessed: Option<RowMajorMatrix<G>>,
-       constraints: Vec<Expr<G>>,
-       lookups: Vec<Lookup<Expr<G>>>,
+       preprocessed: Option<RowMajorMatrix<F>>,
+       constraints: Vec<Expr<F>>,
+       lookups: Vec<Lookup<Expr<F>>>,
        lookup_group_size: usize| {
         slot_widths.push(lookups.iter().map(|l| l.args.len()).collect());
         circuit_inputs.push(CircuitInputs {
@@ -125,30 +123,65 @@ impl AiurSystem {
     // lookups also group 2 per chained step at degree 3 — halving the
     // stage-2 accumulators (Bytes2: 10 → 5 at height 65536).
     push_circuit(
-      Bytes1.main_width(),
-      Bytes1.preprocessed(),
+      AiurGadget::<F>::main_width(&Bytes1),
+      AiurGadget::<F>::preprocessed(&Bytes1),
       vec![],
-      Bytes1.lookups(),
+      AiurGadget::<F>::lookups(&Bytes1),
       2,
     );
     push_circuit(
-      Bytes2.main_width(),
-      Bytes2.preprocessed(),
+      AiurGadget::<F>::main_width(&Bytes2),
+      AiurGadget::<F>::preprocessed(&Bytes2),
       vec![],
-      Bytes2.lookups(),
+      AiurGadget::<F>::lookups(&Bytes2),
       2,
     );
 
+    (circuit_inputs, slot_widths)
+  }
+}
+
+impl AiurSystem {
+  pub fn build(
+    toplevel: Toplevel,
+    commitment_parameters: CommitmentParameters,
+    fri_parameters: FriParameters,
+  ) -> Self {
+    let (circuit_inputs, slot_widths) = build_circuit_inputs(&toplevel);
     let config = AiurConfig::new(commitment_parameters, fri_parameters);
     let (system, key) = System::new(config, circuit_inputs);
-    AiurSystem {
-      system,
-      key,
-      toplevel,
-      commitment_parameters,
-      fri_parameters,
-      slot_widths,
-    }
+    AiurSystem { system, key, toplevel, slot_widths }
+  }
+}
+
+#[cfg(feature = "kzg")]
+impl AiurSystem<multi_stark::ark_adapter::KzgConfig> {
+  /// Build over the BLS12-381 scalar field with the KZG backend (the
+  /// terminal stage: constant-size proofs, natively verified). Public
+  /// parameters are caller-supplied — see `Srs` in multi-stark.
+  pub fn build_kzg(
+    toplevel: Toplevel<multi_stark::ark_adapter::Scalar>,
+    srs: std::sync::Arc<multi_stark::ark_adapter::Srs>,
+    max_quotient_degree: usize,
+  ) -> Self {
+    let (circuit_inputs, slot_widths) = build_circuit_inputs(&toplevel);
+    let config =
+      multi_stark::ark_adapter::KzgConfig::new(srs, max_quotient_degree);
+    let (system, key) = System::new(config, circuit_inputs);
+    AiurSystem { system, key, toplevel, slot_widths }
+  }
+}
+
+impl<SC: ProofConfig> AiurSystem<SC>
+where
+  Val<SC>: AiurField,
+{
+  /// The verification-sufficient part of the bundle: the compiled
+  /// [`System`] (config + circuits + preprocessed commitment/indices).
+  /// The rest of [`AiurSystem`] — toplevel, prover key, slot widths —
+  /// is prover-side only.
+  pub fn system(&self) -> &System<SC> {
+    &self.system
   }
 
   /// The circuit list in system order: constrained functions (ascending
@@ -199,9 +232,15 @@ impl AiurSystem {
   pub fn prove(
     &self,
     fun_idx: FunIdx,
-    input: &[G],
-    io_buffer: &mut IOBuffer,
-  ) -> (Vec<G>, AiurProof) {
+    input: &[Val<SC>],
+    io_buffer: &mut IOBuffer<Val<SC>>,
+  ) -> (Vec<Val<SC>>, Proof<SC>)
+  where
+    // The witness builder fans out per circuit under rayon with `&self`
+    // captured; the bound lands here (not on the impl) so read-only
+    // paths stay unconstrained.
+    Self: Sync,
+  {
     tracing_texray::examine_current();
 
     // Execute the Aiur bytecode.
@@ -247,7 +286,7 @@ impl AiurSystem {
     drop(_g);
 
     // Construct the claim.
-    let mut claim = vec![function_channel(), G::from_usize(fun_idx)];
+    let mut claim = vec![function_channel(), Val::<SC>::from_usize(fun_idx)];
     claim.extend(input);
     claim.extend(output);
 
@@ -267,20 +306,21 @@ impl AiurSystem {
   /// generation are all unchanged — the proof produced here is
   /// verification-compatible with one produced by `prove`.
   #[tracing::instrument(level = "info", skip_all, name = "aiur/prove_ixvm")]
-  pub fn prove_ixvm<F>(
+  pub fn prove_ixvm<E>(
     &self,
     fun_idx: FunIdx,
-    input: &[G],
-    io_buffer: &mut IOBuffer,
-    executor: F,
-  ) -> (Vec<G>, AiurProof)
+    input: &[Val<SC>],
+    io_buffer: &mut IOBuffer<Val<SC>>,
+    executor: E,
+  ) -> (Vec<Val<SC>>, Proof<SC>)
   where
-    F: FnOnce(
-      &Toplevel,
+    E: FnOnce(
+      &Toplevel<Val<SC>>,
       FunIdx,
-      Vec<G>,
-      &mut IOBuffer,
-    ) -> Result<(QueryRecord, Vec<G>), ExecError>,
+      Vec<Val<SC>>,
+      &mut IOBuffer<Val<SC>>,
+    ) -> Result<(QueryRecord<Val<SC>>, Vec<Val<SC>>), ExecError>,
+    Self: Sync,
   {
     tracing_texray::examine_current();
     let _g = tracing::info_span!("aiur/execute_ixvm").entered();
@@ -320,7 +360,7 @@ impl AiurSystem {
     let witness = SystemWitness { traces, lookups };
     drop(_g);
 
-    let mut claim = vec![function_channel(), G::from_usize(fun_idx)];
+    let mut claim = vec![function_channel(), Val::<SC>::from_usize(fun_idx)];
     claim.extend(input);
     claim.extend(output);
 
@@ -331,9 +371,9 @@ impl AiurSystem {
   #[inline]
   pub fn verify(
     &self,
-    claim: &[G],
-    proof: &AiurProof,
-  ) -> Result<(), VerificationError<PcsError>> {
+    claim: &[Val<SC>],
+    proof: &Proof<SC>,
+  ) -> Result<(), VerificationError<PcsError<SC>>> {
     self.system.verify(claim, proof)
   }
 }
@@ -341,12 +381,13 @@ impl AiurSystem {
 #[cfg(test)]
 mod tests {
   use super::*;
+  use crate::G;
   use crate::{
     bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel},
     execute::IOBuffer,
   };
   use multi_stark::{
-    p3_field::PrimeCharacteristicRing,
+    traits::Algebra,
     types::{CommitmentParameters, FriParameters},
   };
   use rustc_hash::FxHashMap;
@@ -366,7 +407,7 @@ mod tests {
     (cp, fp)
   }
 
-  fn empty_io_buffer() -> IOBuffer {
+  pub(super) fn empty_io_buffer<F: AiurField>() -> IOBuffer<F> {
     IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() }
   }
 
@@ -384,7 +425,7 @@ mod tests {
   ///   fresh auxiliary column pinned by `sel * (col - a*b)`.
   /// - `lookups = 1`: the function-provide (return) lookup in slot 0, which
   ///   pulls the claim `[function_channel, fun_idx, a, b, a*b]`.
-  fn mul_toplevel() -> Toplevel {
+  pub(super) fn mul_toplevel<F: AiurField>() -> Toplevel<F> {
     let body =
       Block { ops: vec![Op::Mul(0, 1)], ctrl: Ctrl::Return(0, vec![2]) };
     let function = Function {
@@ -401,7 +442,7 @@ mod tests {
     Toplevel { functions: vec![function], memory_sizes: vec![] }
   }
 
-  fn xor_splits_toplevel() -> Toplevel {
+  pub(super) fn xor_splits_toplevel<F: AiurField>() -> Toplevel<F> {
     let body = Block {
       ops: vec![Op::U8XorSplit7(0, 1), Op::U8XorSplit4(0, 1)],
       ctrl: Ctrl::Return(0, vec![2, 3, 4, 5]),
@@ -708,3 +749,48 @@ mod tests {
     assert_eq!(shapes[4].preprocessed_height, 65536);
   }
 }
+
+#[cfg(all(test, feature = "kzg"))]
+mod kzg_tests {
+  use super::tests::{empty_io_buffer, mul_toplevel, xor_splits_toplevel};
+  use super::*;
+  use multi_stark::ark_adapter::{Scalar, Srs};
+  use multi_stark::traits::{Algebra, Field};
+  use std::sync::Arc;
+
+  fn dev_srs() -> Arc<Srs> {
+    // Bytes2's preprocessed table is 65536 rows, so the SRS must cover
+    // at least 2^16-length columns.
+    Arc::new(Srs::unsafe_dev_setup(1 << 17, b"aiur-kzg-test"))
+  }
+
+  /// Aiur over the BLS12-381 scalar field: build, prove, verify, and
+  /// reject tampering — the same pipeline the Goldilocks tests run,
+  /// with KZG commitments instead of FRI.
+  #[test]
+  fn kzg_prove_verify_mul() {
+    let system = AiurSystem::build_kzg(mul_toplevel::<Scalar>(), dev_srs(), 8);
+    let a = Scalar::from_u64(3);
+    let b = Scalar::from_u64(5);
+    let (claim, proof) = system.prove(0, &[a, b], &mut empty_io_buffer());
+    assert_eq!(claim.last(), Some(&(a * b)));
+    system.verify(&claim, &proof).expect("KZG Aiur proof failed to verify");
+
+    let mut bad_claim = claim.clone();
+    let last = bad_claim.len() - 1;
+    bad_claim[last] += <Scalar as Algebra<Scalar>>::ONE;
+    assert!(system.verify(&bad_claim, &proof).is_err());
+  }
+
+  /// Byte-gadget coverage over Fr: the xor-split ops route through the
+  /// Bytes2 chip (65536-row preprocessed table committed via MSM).
+  #[test]
+  fn kzg_prove_verify_xor_splits() {
+    let system =
+      AiurSystem::build_kzg(xor_splits_toplevel::<Scalar>(), dev_srs(), 8);
+    let a = Scalar::from_u64(0xd3);
+    let b = Scalar::from_u64(0x69);
+    let (claim, proof) = system.prove(0, &[a, b], &mut empty_io_buffer());
+    system.verify(&claim, &proof).expect("KZG Aiur proof failed to verify");
+  }
+}
diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs
index e87dfe15..527fd86a 100644
--- a/crates/aiur/src/trace.rs
+++ b/crates/aiur/src/trace.rs
@@ -1,6 +1,5 @@
 use multi_stark::{
   lookup::{LookupRowMut, LookupValues},
-  p3_field::{Field, PrimeCharacteristicRing, PrimeField64},
   p3_matrix::dense::RowMajorMatrix,
 };
 use rayon::{
@@ -11,11 +10,11 @@ use rayon::{
 };
 
 use crate::{
-  FxIndexMap, G,
+  AiurField, FxIndexMap,
   bytecode::{Block, Ctrl, Function, Op, Toplevel},
   execute::{
     IOBuffer, IOKeyInfo, QueryRecord, find_unconstrained_big_uint_div_mod,
-    g_inverse_value,
+    g_inverse_value, gl_divmod_value, gl_inverse_value,
   },
   function_channel,
   gadgets::{bytes1::Bytes1, bytes2::Bytes2},
@@ -31,34 +30,34 @@ struct ColumnIndex {
   lookup: usize,
 }
 
-struct ColumnMutSlice<'a, 'b> {
-  inputs: &'a mut [G],
-  selectors: &'a mut [G],
-  auxiliaries: &'a mut [G],
-  lookups: &'a mut LookupRowMut<'b, G>,
+struct ColumnMutSlice<'a, 'b, F> {
+  inputs: &'a mut [F],
+  selectors: &'a mut [F],
+  auxiliaries: &'a mut [F],
+  lookups: &'a mut LookupRowMut<'b, F>,
 }
 
 type Degree = u8;
 
-fn u32_value(map: &[(G, Degree)], bytes: &[usize]) -> u64 {
+fn u32_value<F: AiurField>(map: &[(F, Degree)], bytes: &[usize]) -> u64 {
   assert_eq!(bytes.len(), 4, "u32 operation requires four bytes");
   bytes.iter().enumerate().fold(0, |word, (i, idx)| {
     word | (map[*idx].0.as_canonical_u64() << (8 * i))
   })
 }
 
-fn u32_sum(values: &[u64]) -> ([G; 4], G) {
+fn u32_sum<F: AiurField>(values: &[u64]) -> ([F; 4], F) {
   let sum: u128 = values.iter().map(|x| u128::from(*x)).sum();
   let word = u32::try_from(sum & 0xFFFF_FFFF).expect("masked to 32 bits");
   let carry = u64::try_from(sum >> 32).expect("sum of u32 words fits in u64");
-  (word.to_le_bytes().map(|b| G::from_u64(b.into())), G::from_u64(carry))
+  (word.to_le_bytes().map(|b| F::from_u64(b.into())), F::from_u64(carry))
 }
 
-impl<'a, 'b> ColumnMutSlice<'a, 'b> {
+impl<'a, 'b, F: AiurField> ColumnMutSlice<'a, 'b, F> {
   fn from_slice(
-    function: &Function,
-    slice: &'a mut [G],
-    lookups: &'a mut LookupRowMut<'b, G>,
+    function: &Function<F>,
+    slice: &'a mut [F],
+    lookups: &'a mut LookupRowMut<'b, F>,
   ) -> Self {
     let (inputs, slice) = slice.split_at_mut(function.layout.input_size);
     let (selectors, slice) = slice.split_at_mut(function.layout.selectors);
@@ -67,7 +66,7 @@ impl<'a, 'b> ColumnMutSlice<'a, 'b> {
     Self { inputs, selectors, auxiliaries, lookups }
   }
 
-  fn push_auxiliary(&mut self, index: &mut ColumnIndex, t: G) {
+  fn push_auxiliary(&mut self, index: &mut ColumnIndex, t: F) {
     self.auxiliaries[index.auxiliary] = t;
     index.auxiliary += 1;
   }
@@ -75,8 +74,8 @@ impl<'a, 'b> ColumnMutSlice<'a, 'b> {
   fn push_lookup(
     &mut self,
     index: &mut ColumnIndex,
-    multiplicity: G,
-    args: &[G],
+    multiplicity: F,
+    args: &[F],
   ) {
     self.lookups.push(index.lookup, multiplicity, args);
     index.lookup += 1;
@@ -84,22 +83,22 @@ impl<'a, 'b> ColumnMutSlice<'a, 'b> {
 }
 
 #[derive(Clone, Copy)]
-struct TraceContext<'a> {
-  function_index: G,
-  multiplicity: G,
-  inputs: &'a [G],
-  output: &'a [G],
-  query_record: &'a QueryRecord,
+struct TraceContext<'a, F: Copy> {
+  function_index: F,
+  multiplicity: F,
+  inputs: &'a [F],
+  output: &'a [F],
+  query_record: &'a QueryRecord<F>,
 }
 
-impl Toplevel {
+impl<F: AiurField> Toplevel<F> {
   pub fn witness_data(
     &self,
     function_index: usize,
-    query_record: &QueryRecord,
-    io_buffer: &IOBuffer,
+    query_record: &QueryRecord<F>,
+    io_buffer: &IOBuffer<F>,
     slot_arg_widths: &[usize],
-  ) -> (RowMajorMatrix<G>, LookupValues<G>) {
+  ) -> (RowMajorMatrix<F>, LookupValues<F>) {
     let func = &self.functions[function_index];
     let width = func.width();
     let unfiltered_queries = &query_record.function_queries[function_index];
@@ -115,7 +114,7 @@ impl Toplevel {
     } else {
       height_no_padding.next_power_of_two()
     };
-    let mut rows = vec![G::ZERO; height * width];
+    let mut rows = vec![F::ZERO; height * width];
     let rows_no_padding = &mut rows[0..height_no_padding * width];
     // Builder rows start zeroed (`Lookup::empty()` in every slot), so padding
     // rows need no writes at all.
@@ -134,7 +133,7 @@ impl Toplevel {
         };
         let slice = &mut ColumnMutSlice::from_slice(func, row, lookups);
         let context = TraceContext {
-          function_index: G::from_usize(function_index),
+          function_index: F::from_usize(function_index),
           inputs,
           multiplicity: result.multiplicity,
           output: result.output,
@@ -148,7 +147,7 @@ impl Toplevel {
   }
 }
 
-impl Function {
+impl<F: AiurField> Function<F> {
   pub fn width(&self) -> usize {
     self.layout.input_size + self.layout.auxiliaries + self.layout.selectors
   }
@@ -156,9 +155,9 @@ impl Function {
   fn populate_row(
     &self,
     index: &mut ColumnIndex,
-    slice: &mut ColumnMutSlice<'_, '_>,
-    context: TraceContext<'_>,
-    io_buffer: &IOBuffer,
+    slice: &mut ColumnMutSlice<'_, '_, F>,
+    context: TraceContext<'_, F>,
+    io_buffer: &IOBuffer<F>,
   ) {
     debug_assert_eq!(
       self.layout.input_size,
@@ -181,17 +180,17 @@ impl Function {
 
 /// `Some(values)` means the block ended with `Yield` (values for the merge).
 /// `None` means the block ended with `Return` (function exited).
-type PopulateResult = Option<Vec<G>>;
+type PopulateResult<F> = Option<Vec<F>>;
 
-impl Block {
+impl<F: AiurField> Block<F> {
   fn populate_row(
     &self,
-    map: &mut Vec<(G, Degree)>,
+    map: &mut Vec<(F, Degree)>,
     index: &mut ColumnIndex,
-    slice: &mut ColumnMutSlice<'_, '_>,
-    context: TraceContext<'_>,
-    io_buffer: &IOBuffer,
-  ) -> PopulateResult {
+    slice: &mut ColumnMutSlice<'_, '_, F>,
+    context: TraceContext<'_, F>,
+    io_buffer: &IOBuffer<F>,
+  ) -> PopulateResult<F> {
     self
       .ops
       .iter()
@@ -202,13 +201,13 @@ impl Block {
 
 /// Dispatch a match: look up the value in the cases map, or fall through to the
 /// default (pushing inverse witnesses for each case to prove inequality).
-fn dispatch_branch<'a>(
-  val: G,
-  cases: &'a FxIndexMap<G, Block>,
-  def: &'a Option<Box<Block>>,
+fn dispatch_branch<'a, F: AiurField>(
+  val: F,
+  cases: &'a FxIndexMap<F, Block<F>>,
+  def: &'a Option<Box<Block<F>>>,
   index: &mut ColumnIndex,
-  slice: &mut ColumnMutSlice<'_, '_>,
-) -> &'a Block {
+  slice: &mut ColumnMutSlice<'_, '_, F>,
+) -> &'a Block<F> {
   cases
     .get(&val)
     .or_else(|| {
@@ -221,18 +220,18 @@ fn dispatch_branch<'a>(
     .expect("No match")
 }
 
-impl Ctrl {
+impl<F: AiurField> Ctrl<F> {
   fn populate_row(
     &self,
-    map: &mut Vec<(G, Degree)>,
+    map: &mut Vec<(F, Degree)>,
     index: &mut ColumnIndex,
-    slice: &mut ColumnMutSlice<'_, '_>,
-    context: TraceContext<'_>,
-    io_buffer: &IOBuffer,
-  ) -> PopulateResult {
+    slice: &mut ColumnMutSlice<'_, '_, F>,
+    context: TraceContext<'_, F>,
+    io_buffer: &IOBuffer<F>,
+  ) -> PopulateResult<F> {
     match self {
       Ctrl::Return(sel, _) => {
-        slice.selectors[*sel] = G::ONE;
+        slice.selectors[*sel] = F::ONE;
         let args = function_lookup_args(
           context.function_index,
           context.inputs,
@@ -244,7 +243,7 @@ impl Ctrl {
         None
       },
       Ctrl::Yield(sel, vals) => {
-        slice.selectors[*sel] = G::ONE;
+        slice.selectors[*sel] = F::ONE;
         Some(vals.iter().map(|&v| map[v].0).collect())
       },
       Ctrl::Match(var, cases, def) => {
@@ -287,14 +286,14 @@ impl Ctrl {
   }
 }
 
-impl Op {
+impl<F: AiurField> Op<F> {
   fn populate_row(
     &self,
-    map: &mut Vec<(G, Degree)>,
+    map: &mut Vec<(F, Degree)>,
     index: &mut ColumnIndex,
-    slice: &mut ColumnMutSlice<'_, '_>,
-    context: TraceContext<'_>,
-    io_buffer: &IOBuffer,
+    slice: &mut ColumnMutSlice<'_, '_, F>,
+    context: TraceContext<'_, F>,
+    io_buffer: &IOBuffer<F>,
   ) {
     match self {
       Op::Const(f) => map.push((*f, 0)),
@@ -324,13 +323,13 @@ impl Op {
       },
       Op::EqZero(a) => {
         let (a, deg) = map[*a];
-        let is_zero = a == G::ZERO;
-        let is_zero_g = G::from_bool(is_zero);
+        let is_zero = a == F::ZERO;
+        let is_zero_g = F::from_bool(is_zero);
         if deg == 0 {
           map.push((is_zero_g, 0));
         } else {
           let (d, x) =
-            if is_zero { (G::ZERO, G::ONE) } else { (a.inverse(), G::ZERO) };
+            if is_zero { (F::ZERO, F::ONE) } else { (a.inverse(), F::ZERO) };
           slice.push_auxiliary(index, d);
           slice.push_auxiliary(index, x);
           map.push((is_zero_g, 1));
@@ -346,11 +345,11 @@ impl Op {
         }
         if !op_unconstrained {
           let args = function_lookup_args(
-            G::from_usize(*function_index),
+            F::from_usize(*function_index),
             &inputs,
             result.output,
           );
-          slice.push_lookup(index, G::ONE, &args);
+          slice.push_lookup(index, F::ONE, &args);
         }
       },
       Op::Store(values) => {
@@ -361,13 +360,13 @@ impl Op {
           .get(&size)
           .expect("Invalid memory size");
         let values = values.iter().map(|a| map[*a].0).collect::<Vec<_>>();
-        let ptr = G::from_usize(
+        let ptr = F::from_usize(
           memory_queries.get_index_of(&values).expect("Unbound pointer"),
         );
         map.push((ptr, 1));
         slice.push_auxiliary(index, ptr);
-        let args = Memory::lookup_args(G::from_usize(size), ptr, &values);
-        slice.push_lookup(index, G::ONE, &args);
+        let args = Memory::lookup_args(F::from_usize(size), ptr, &values);
+        slice.push_lookup(index, F::ONE, &args);
       },
       Op::Load(size, ptr) => {
         let memory_queries = context
@@ -384,15 +383,15 @@ impl Op {
           map.push((*f, 1));
           slice.push_auxiliary(index, *f);
         }
-        let args = Memory::lookup_args(G::from_usize(*size), ptr, values);
-        slice.push_lookup(index, G::ONE, &args);
+        let args = Memory::lookup_args(F::from_usize(*size), ptr, values);
+        slice.push_lookup(index, F::ONE, &args);
       },
       Op::IOGetInfo(channel, key) => {
         let channel = map[*channel].0;
         let key = key.iter().map(|a| map[*a].0).collect::<Vec<_>>();
         let IOKeyInfo { idx, len } =
           io_buffer.get_info(channel, &key).expect("Invalid IO key");
-        for f in [G::from_usize(*idx), G::from_usize(*len)] {
+        for f in [F::from_usize(*idx), F::from_usize(*len)] {
           map.push((f, 1));
           slice.push_auxiliary(index, f);
         }
@@ -422,7 +421,7 @@ impl Op {
         }
         let mut lookup_args = vec![u8_bit_decomposition_channel(), byte];
         lookup_args.extend(bits);
-        slice.push_lookup(index, G::ONE, &lookup_args);
+        slice.push_lookup(index, F::ONE, &lookup_args);
       },
       Op::U8ShiftLeft(byte) => {
         let (byte, _) = map[*byte];
@@ -431,7 +430,7 @@ impl Op {
         slice.push_auxiliary(index, byte_shifted);
         slice.push_lookup(
           index,
-          G::ONE,
+          F::ONE,
           &[u8_shift_left_channel(), byte, byte_shifted],
         );
       },
@@ -442,7 +441,7 @@ impl Op {
         slice.push_auxiliary(index, byte_shifted);
         slice.push_lookup(
           index,
-          G::ONE,
+          F::ONE,
           &[u8_shift_right_channel(), byte, byte_shifted],
         );
       },
@@ -452,7 +451,7 @@ impl Op {
         let xor = Bytes2::xor(&i, &j);
         map.push((xor, 1));
         slice.push_auxiliary(index, xor);
-        slice.push_lookup(index, G::ONE, &[u8_xor_channel(), i, j, xor]);
+        slice.push_lookup(index, F::ONE, &[u8_xor_channel(), i, j, xor]);
       },
       Op::U8Add(i, j) => {
         let (i, _) = map[*i];
@@ -464,7 +463,7 @@ impl Op {
         map.push((r, 1));
         map.push((o, 1));
         slice.push_auxiliary(index, r);
-        slice.push_lookup(index, G::ONE, &[u8_add_channel(), i, j, r]);
+        slice.push_lookup(index, F::ONE, &[u8_add_channel(), i, j, r]);
       },
       Op::UnconstrainedU32Add(a, b) => {
         let (bytes, carry) = u32_sum(&[u32_value(map, a), u32_value(map, b)]);
@@ -486,7 +485,7 @@ impl Op {
       Op::U32ToField(bytes) => {
         let word = u32_value(map, bytes);
         let degree = bytes.iter().map(|idx| map[*idx].1).max().unwrap_or(0);
-        map.push((G::from_u64(word), degree));
+        map.push((F::from_u64(word), degree));
       },
       Op::U8Mul(i, j) => {
         let (i, _) = map[*i];
@@ -496,7 +495,7 @@ impl Op {
         map.push((hi, 1));
         slice.push_auxiliary(index, lo);
         slice.push_auxiliary(index, hi);
-        slice.push_lookup(index, G::ONE, &[u8_mul_channel(), i, j, lo, hi]);
+        slice.push_lookup(index, F::ONE, &[u8_mul_channel(), i, j, lo, hi]);
       },
       Op::U8Sub(i, j) => {
         let (i, _) = map[*i];
@@ -508,7 +507,7 @@ impl Op {
         map.push((r, 1));
         map.push((u, 1));
         slice.push_auxiliary(index, r);
-        slice.push_lookup(index, G::ONE, &[u8_sub_channel(), i, j, r]);
+        slice.push_lookup(index, F::ONE, &[u8_sub_channel(), i, j, r]);
       },
       Op::U8And(i, j) => {
         let (i, _) = map[*i];
@@ -516,7 +515,7 @@ impl Op {
         let and = Bytes2::and(&i, &j);
         map.push((and, 1));
         slice.push_auxiliary(index, and);
-        slice.push_lookup(index, G::ONE, &[u8_and_channel(), i, j, and]);
+        slice.push_lookup(index, F::ONE, &[u8_and_channel(), i, j, and]);
       },
       Op::U8Or(i, j) => {
         let (i, _) = map[*i];
@@ -524,7 +523,7 @@ impl Op {
         let or = Bytes2::or(&i, &j);
         map.push((or, 1));
         slice.push_auxiliary(index, or);
-        slice.push_lookup(index, G::ONE, &[u8_or_channel(), i, j, or]);
+        slice.push_lookup(index, F::ONE, &[u8_or_channel(), i, j, or]);
       },
       Op::U8LessThan(i, j) => {
         let (i, _) = map[*i];
@@ -534,7 +533,7 @@ impl Op {
         slice.push_auxiliary(index, less_than);
         slice.push_lookup(
           index,
-          G::ONE,
+          F::ONE,
           &[u8_less_than_channel(), i, j, less_than],
         );
       },
@@ -547,7 +546,7 @@ impl Op {
         slice.push_auxiliary(index, lo);
         slice.push_lookup(
           index,
-          G::ONE,
+          F::ONE,
           &[u8_xor_split7_channel(), i, j, hi, lo],
         );
       },
@@ -560,7 +559,7 @@ impl Op {
         slice.push_auxiliary(index, lo);
         slice.push_lookup(
           index,
-          G::ONE,
+          F::ONE,
           &[u8_xor_split4_channel(), i, j, hi, lo],
         );
       },
@@ -578,7 +577,7 @@ impl Op {
         // Push 12 byte auxiliaries: x (a bytes), y (c bytes), z (b bytes)
         for &byte in x_bytes.iter().chain(y_bytes.iter()).chain(z_bytes.iter())
         {
-          slice.push_auxiliary(index, G::from_u8(byte));
+          slice.push_auxiliary(index, F::from_u8(byte));
         }
 
         // Range-check byte pairs via Bytes2 lookups
@@ -593,12 +592,12 @@ impl Op {
         ] {
           slice.push_lookup(
             index,
-            G::ONE,
-            &[rc_channel, G::from_u8(i), G::from_u8(j)],
+            F::ONE,
+            &[rc_channel, F::from_u8(i), F::from_u8(j)],
           );
         }
 
-        let result = G::from_bool(a_u32 < b_u32);
+        let result = F::from_bool(a_u32 < b_u32);
         map.push((result, 1));
       },
       Op::U8RangeCheck(i, j) => {
@@ -606,7 +605,7 @@ impl Op {
         // `(i, j)` pair from the byte-chip range-check table.
         slice.push_lookup(
           index,
-          G::ONE,
+          F::ONE,
           &[u8_range_check_channel(), map[*i].0, map[*j].0],
         );
       },
@@ -632,7 +631,7 @@ impl Op {
         // the 8 auxiliary columns the constraints allocate.
         let bytes = map[*a].0.as_canonical_u64().to_le_bytes();
         for b in bytes {
-          let f = G::from_u8(b);
+          let f = F::from_u8(b);
           map.push((f, 1));
           slice.push_auxiliary(index, f);
         }
@@ -642,6 +641,18 @@ impl Op {
         map.push((f, 1));
         slice.push_auxiliary(index, f);
       },
+      Op::UnconstrainedGlDivMod(a) => {
+        let (q, r) = gl_divmod_value(map[*a].0);
+        for f in [q, r] {
+          map.push((f, 1));
+          slice.push_auxiliary(index, f);
+        }
+      },
+      Op::UnconstrainedGlInverse(a) => {
+        let f = gl_inverse_value(map[*a].0);
+        map.push((f, 1));
+        slice.push_auxiliary(index, f);
+      },
       Op::AssertEq(..)
       | Op::IOSetInfo(..)
       | Op::IOWrite(..)
@@ -650,11 +661,11 @@ impl Op {
   }
 }
 
-fn function_lookup_args(
-  function_index: G,
-  inputs: &[G],
-  output: &[G],
-) -> Vec<G> {
+fn function_lookup_args<F: AiurField>(
+  function_index: F,
+  inputs: &[F],
+  output: &[F],
+) -> Vec<F> {
   let mut args = vec![function_channel(), function_index];
   args.extend(inputs);
   args.extend(output);
diff --git a/crates/aiur/src/vk_codec.rs b/crates/aiur/src/vk_codec.rs
index 9fa9e00e..3cd2065e 100644
--- a/crates/aiur/src/vk_codec.rs
+++ b/crates/aiur/src/vk_codec.rs
@@ -62,6 +62,7 @@
 #![allow(dead_code)]
 
 use multi_stark::{
+  config::ProofConfig,
   expr::{ColRef, RowOffset, Source},
   graph::{ConstraintGraph, Node, NodeId},
   lookup::Lookup,
@@ -70,7 +71,7 @@ use multi_stark::{
   types::{Commitment, CommitmentParameters, FriParameters, Val},
 };
 
-use crate::synthesis::{AiurConfig, AiurSystem};
+use crate::synthesis::AiurConfig;
 
 /// Sentinel for `None` in the preprocessed-index trailer.
 const NO_PREP_INDEX: u16 = u16::MAX;
@@ -239,9 +240,12 @@ pub(crate) fn to_bytes(
   buf
 }
 
-/// Convenience: serialize the verifying key of a built [`AiurSystem`].
-pub fn aiur_system_to_bytes(sys: &AiurSystem) -> Result<Vec<u8>, String> {
-  Ok(to_bytes(&sys.system, sys.commitment_parameters, sys.fri_parameters))
+/// Serialize the verifying key of a [`System`]. The codec is
+/// System-level: verification (native or recursive) never needs the
+/// prover-side [`AiurSystem`] bundle (toplevel, prover key).
+pub fn system_to_bytes(system: &System<AiurConfig>) -> Result<Vec<u8>, String> {
+  let pcs = system.config.pcs();
+  Ok(to_bytes(system, pcs.commitment_parameters(), pcs.fri_parameters()))
 }
 
 // ════════════════════════════════════════════════════════════════════════════
@@ -438,9 +442,7 @@ fn zeros_plus_logup(
 /// Deserialize a `System<AiurConfig>` from [`to_bytes`] output, requiring that
 /// every byte is consumed. Also returns the config's construction parameters,
 /// which the `System` itself doesn't expose.
-pub(crate) fn from_bytes(
-  bytes: &[u8],
-) -> Result<(System<AiurConfig>, CommitmentParameters, FriParameters), String> {
+pub(crate) fn from_bytes(bytes: &[u8]) -> Result<System<AiurConfig>, String> {
   let mut r = Seg { buf: bytes, pos: 0 };
   let commitment_parameters = CommitmentParameters {
     log_blowup: r.u16()? as usize,
@@ -488,7 +490,7 @@ pub(crate) fn from_bytes(
     preprocessed_commit,
     preprocessed_indices,
   };
-  Ok((system, commitment_parameters, fri_parameters))
+  Ok(system)
 }
 
 #[cfg(test)]
@@ -514,19 +516,19 @@ mod tests {
     let (cp, fp) = test_parameters();
     let inputs = [
       CircuitInputs {
-        main_width: Bytes1.main_width(),
-        preprocessed: Bytes1.preprocessed(),
+        main_width: AiurGadget::<crate::G>::main_width(&Bytes1),
+        preprocessed: AiurGadget::<crate::G>::preprocessed(&Bytes1),
         constraints: vec![],
         ext_constraints: vec![],
-        lookups: Bytes1.lookups(),
+        lookups: AiurGadget::<crate::G>::lookups(&Bytes1),
         lookup_group_size: 1,
       },
       CircuitInputs {
-        main_width: Bytes2.main_width(),
-        preprocessed: Bytes2.preprocessed(),
+        main_width: AiurGadget::<crate::G>::main_width(&Bytes2),
+        preprocessed: AiurGadget::<crate::G>::preprocessed(&Bytes2),
         constraints: vec![],
         ext_constraints: vec![],
-        lookups: Bytes2.lookups(),
+        lookups: AiurGadget::<crate::G>::lookups(&Bytes2),
         // Grouped-circuit coverage: the codec must carry the group size
         // through (it changes the derived stage-2 width and count).
         lookup_group_size: 2,
@@ -542,8 +544,13 @@ mod tests {
   fn system_vk_round_trips() {
     let (system, cp, fp) = test_system();
     let bytes = to_bytes(&system, cp, fp);
-    let (back, back_cp, back_fp) = from_bytes(&bytes).expect("decode");
-    let reencoded = to_bytes(&back, back_cp, back_fp);
+    let back = from_bytes(&bytes).expect("decode");
+    let back_pcs = back.config.pcs();
+    let reencoded = to_bytes(
+      &back,
+      back_pcs.commitment_parameters(),
+      back_pcs.fri_parameters(),
+    );
     assert_eq!(bytes, reencoded, "verifying-key codec round-trip mismatch");
     assert_eq!(system.circuits.len(), back.circuits.len());
     for (a, b) in system.circuits.iter().zip(&back.circuits) {
diff --git a/crates/ffi/Cargo.toml b/crates/ffi/Cargo.toml
index 1e02a9a6..42a8719e 100644
--- a/crates/ffi/Cargo.toml
+++ b/crates/ffi/Cargo.toml
@@ -48,6 +48,7 @@ serde = { version = "1.0.219", features = ["derive"], optional = true }
 [features]
 default = []
 parallel = ["aiur/parallel"]
+kzg = ["aiur/kzg", "multi-stark/kzg"]
 test-ffi = []
 net = ["bytes", "tokio", "iroh", "iroh-base", "n0-error", "getrandom", "bincode", "serde"]
 
diff --git a/crates/ffi/src/aiur.rs b/crates/ffi/src/aiur.rs
index 01ad45ac..685f2d1b 100644
--- a/crates/ffi/src/aiur.rs
+++ b/crates/ffi/src/aiur.rs
@@ -17,3 +17,62 @@ pub(super) fn lean_unbox_g(obj: &impl LeanRef) -> G {
   let u64 = obj.unbox_u64();
   unsafe { G::from_canonical_unchecked(u64) }
 }
+
+/// Specialize an exact-`Nat` constant (bytecode `Op.const` / match key)
+/// into the field. Overflow is an ERROR: a constant `>= p` means the
+/// field cannot represent this circuit — never wrap.
+pub(super) fn lean_nat_as_field(obj: &impl LeanRef) -> G {
+  use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
+  let n = lean_ffi::object::LeanNat::to_nat(obj);
+  match n.to_u64() {
+    Some(v) if v < G::ORDER_U64 => G::from_u64(v),
+    _ => panic!(
+      "constant {n} does not fit the field (order {}): the field cannot \
+       represent this circuit",
+      G::ORDER_U64
+    ),
+  }
+}
+
+/// Field-side decoding of Lean values, per outer field: the checked
+/// exact-`Nat` embedding (bytecode constants / match keys) and the
+/// boxed-u64 wire value (public inputs, claims). Implemented for the
+/// default Goldilocks and (behind `kzg`) the BLS12-381 scalar field.
+pub(super) trait LeanField: aiur::AiurField {
+  fn from_lean_nat(obj: &impl LeanRef) -> Self;
+  /// Used by the `kzg`-gated externs; the Goldilocks paths unbox directly.
+  #[allow(dead_code)]
+  fn from_lean_u64(obj: &impl LeanRef) -> Self;
+}
+
+impl LeanField for G {
+  fn from_lean_nat(obj: &impl LeanRef) -> Self {
+    lean_nat_as_field(obj)
+  }
+  fn from_lean_u64(obj: &impl LeanRef) -> Self {
+    lean_unbox_g(obj)
+  }
+}
+
+#[cfg(feature = "kzg")]
+impl LeanField for multi_stark::ark_adapter::Scalar {
+  fn from_lean_nat(obj: &impl LeanRef) -> Self {
+    use multi_stark::traits::Field;
+    let n = lean_ffi::object::LeanNat::to_nat(obj);
+    // Every constant a toplevel ships today is < 2^64 (bytes, wire
+    // words, counters), which embeds exactly in the ~2^255 scalar
+    // field. Larger exact naturals would need a multi-limb embedding —
+    // reject loudly instead of guessing.
+    match n.to_u64() {
+      Some(v) => Self::from_u64(v),
+      None => panic!(
+        "constant {n} exceeds 2^64: multi-limb constant embedding is not \
+         implemented for the BLS12-381 scalar field"
+      ),
+    }
+  }
+  fn from_lean_u64(obj: &impl LeanRef) -> Self {
+    use multi_stark::traits::Field;
+    Self::from_u64(obj.unbox_u64())
+  }
+}
diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs
index e0edaea5..8713ef58 100644
--- a/crates/ffi/src/aiur/protocol.rs
+++ b/crates/ffi/src/aiur/protocol.rs
@@ -67,7 +67,7 @@ extern "C" fn rs_aiur_proof_of_bytes(
 extern "C" fn rs_aiur_system_vk_bytes(
   system: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
 ) -> LeanByteArray<LeanOwned> {
-  let bytes = aiur::vk_codec::aiur_system_to_bytes(system.get())
+  let bytes = aiur::vk_codec::system_to_bytes(system.get().system())
     .expect("VK serialization error");
   LeanByteArray::from_bytes(&bytes)
 }
@@ -865,3 +865,109 @@ fn decode_io_buffer_map(
   }
   map
 }
+
+// =============================================================================
+// KZG (BLS12-381) instantiation — the stage-3 wrap
+// =============================================================================
+
+/// The stage-3 FFI surface: the foreign (byte-limb) verifier toplevel
+/// specialized to the BLS12-381 scalar field and proven under the KZG
+/// backend. Execution is the generic Aiur interpreter over `Scalar` —
+/// there is no codegen'd Fr runner yet.
+#[cfg(feature = "kzg")]
+mod kzg {
+  use super::*;
+  use crate::aiur::LeanField;
+  use multi_stark::ark_adapter::{KzgConfig, Scalar, Srs};
+  use multi_stark::prover::Proof;
+
+  type AiurKzgSystem = AiurSystem<KzgConfig>;
+
+  static AIUR_KZG_SYSTEM_CLASS: LazyLock<ExternalClass> =
+    LazyLock::new(ExternalClass::register_with_drop::<AiurKzgSystem>);
+
+  /// `AiurKzgSystem.build : @&Bytecode.Toplevel → Nat → Nat → AiurKzgSystem`
+  ///
+  /// Public parameters are DEV-GRADE (`Srs::unsafe_dev_setup`, size
+  /// `2^log_srs_size`): stage-3 parameters are bring-your-own, and the
+  /// dev setup stands in until a ceremony loader lands.
+  #[unsafe(no_mangle)]
+  extern "C" fn rs_aiur_kzg_system_build(
+    toplevel: LeanAiurToplevel<LeanBorrowed<'_>>,
+    log_srs_size: LeanNat<LeanBorrowed<'_>>,
+    max_quotient_degree: LeanNat<LeanBorrowed<'_>>,
+  ) -> LeanExternal<AiurKzgSystem, LeanOwned> {
+    let toplevel = decode_toplevel::<Scalar>(&toplevel);
+    let log = lean_unbox_nat_as_usize(log_srs_size.inner());
+    let max_quotient_degree =
+      lean_unbox_nat_as_usize(max_quotient_degree.inner());
+    let srs =
+      std::sync::Arc::new(Srs::unsafe_dev_setup(1usize << log, b"ix-dev-srs"));
+    let system = AiurSystem::build_kzg(toplevel, srs, max_quotient_degree);
+    LeanExternal::alloc(&AIUR_KZG_SYSTEM_CLASS, system)
+  }
+
+  /// Claim values as a Lean `Array G` (boxed u64s). Exact: a claim's
+  /// values are channels, function indices, and 4-byte-packed digest
+  /// limbs — all far below 2^64.
+  fn build_scalar_claim_array(values: &[Scalar]) -> LeanArray<LeanOwned> {
+    let arr = LeanArray::alloc(values.len());
+    for (i, v) in values.iter().enumerate() {
+      arr.set(i, LeanOwned::box_u64(aiur::AiurField::as_canonical_u64(v)));
+    }
+    arr
+  }
+
+  /// `AiurKzgSystem.proveMultiStark`: prove the foreign verifier over
+  /// raw proof/vk/claims byte blobs (advice layout as in
+  /// `rs_aiur_multi_stark_prove`), over the scalar field. Returns
+  /// `(claim, proofBytes)` — the KZG proof travels as bytes; `verify`
+  /// deserializes.
+  #[unsafe(no_mangle)]
+  extern "C" fn rs_aiur_kzg_multi_stark_prove(
+    system: LeanExternal<AiurKzgSystem, LeanBorrowed<'_>>,
+    fun_idx: LeanNat<LeanBorrowed<'_>>,
+    pub_input: LeanArray<LeanBorrowed<'_>>,
+    proof_bytes: LeanByteArray<LeanBorrowed<'_>>,
+    vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+    claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  ) -> LeanOwned {
+    let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
+    let mut io_buffer =
+      ixvm_codegen::aiur_multi_stark_runner::verifier_io_buffer_in::<Scalar>(
+        proof_bytes.as_bytes(),
+        vk_bytes.as_bytes(),
+        claims_bytes.as_bytes(),
+      );
+    let args = pub_input.map(|x| Scalar::from_lean_u64(&x));
+    let (claim, proof) = system.get().prove(fun_idx, &args, &mut io_buffer);
+    let bytes = proof.to_bytes().expect("Serialization error");
+    let result = LeanProd::new(
+      build_scalar_claim_array(&claim),
+      LeanByteArray::from_bytes(&bytes),
+    );
+    result.into()
+  }
+
+  /// `AiurKzgSystem.verify : @&AiurKzgSystem → @&Array G → @&ByteArray →
+  /// Except String Unit` — the NATIVE (milliseconds, two-pairing) check
+  /// of a stage-3 proof.
+  #[unsafe(no_mangle)]
+  extern "C" fn rs_aiur_kzg_system_verify(
+    system: LeanExternal<AiurKzgSystem, LeanBorrowed<'_>>,
+    claim: LeanArray<LeanBorrowed<'_>>,
+    proof_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  ) -> LeanExcept<LeanOwned> {
+    let claim = claim.map(|x| Scalar::from_lean_u64(&x));
+    let proof = match Proof::<KzgConfig>::from_bytes(proof_bytes.as_bytes()) {
+      Ok(p) => p,
+      Err(e) => {
+        return LeanExcept::error_string(&format!("proof decode: {e}"));
+      },
+    };
+    match system.get().verify(&claim, &proof) {
+      Ok(()) => LeanExcept::ok(LeanOwned::box_usize(0)),
+      Err(e) => LeanExcept::error_string(&format!("{e:?}")),
+    }
+  }
+}
diff --git a/crates/ffi/src/aiur/toplevel.rs b/crates/ffi/src/aiur/toplevel.rs
index 4b88cdac..17c5baf1 100644
--- a/crates/ffi/src/aiur/toplevel.rs
+++ b/crates/ffi/src/aiur/toplevel.rs
@@ -1,26 +1,24 @@
-use multi_stark::p3_field::PrimeCharacteristicRing;
-
 use lean_ffi::object::{LeanBorrowed, LeanCtor, LeanRef};
 
 use crate::lean::LeanAiurFunction;
 
 use crate::lean::LeanAiurToplevel;
 use aiur::{
-  FxIndexMap, G,
+  FxIndexMap,
   bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel, ValIdx},
 };
 
-use crate::aiur::{lean_unbox_g, lean_unbox_nat_as_usize};
+use crate::aiur::{LeanField, lean_unbox_nat_as_usize};
 
 fn decode_vec_val_idx(obj: LeanBorrowed<'_>) -> Vec<ValIdx> {
   obj.as_array().map(|x| lean_unbox_nat_as_usize(&x))
 }
 
-fn decode_op(ctor: LeanCtor<LeanBorrowed<'_>>) -> Op {
+fn decode_op<F: LeanField>(ctor: LeanCtor<LeanBorrowed<'_>>) -> Op<F> {
   match ctor.tag() {
     0 => {
       let [const_val] = ctor.objs::<1>();
-      Op::Const(G::from_u64(const_val.as_enum_tag() as u64))
+      Op::Const(F::from_lean_nat(&const_val))
     },
     1 => {
       let [a, b] = ctor.objs::<2>();
@@ -189,18 +187,28 @@ fn decode_op(ctor: LeanCtor<LeanBorrowed<'_>>) -> Op {
       let [a] = ctor.objs::<1>();
       Op::U32ToField(decode_vec_val_idx(a))
     },
+    34 => {
+      let [a] = ctor.objs::<1>().map(|x| lean_unbox_nat_as_usize(&x));
+      Op::UnconstrainedGlDivMod(a)
+    },
+    35 => {
+      let [a] = ctor.objs::<1>().map(|x| lean_unbox_nat_as_usize(&x));
+      Op::UnconstrainedGlInverse(a)
+    },
     _ => unreachable!(),
   }
 }
 
-fn decode_g_block_pair(ctor: LeanCtor<LeanBorrowed<'_>>) -> (G, Block) {
+fn decode_g_block_pair<F: LeanField>(
+  ctor: LeanCtor<LeanBorrowed<'_>>,
+) -> (F, Block<F>) {
   let [g_obj, block_obj] = ctor.objs::<2>();
-  let g = lean_unbox_g(&g_obj);
+  let g = F::from_lean_nat(&g_obj);
   let block = decode_block(block_obj.as_ctor());
   (g, block)
 }
 
-fn decode_ctrl(ctor: LeanCtor<LeanBorrowed<'_>>) -> Ctrl {
+fn decode_ctrl<F: LeanField>(ctor: LeanCtor<LeanBorrowed<'_>>) -> Ctrl<F> {
   match ctor.tag() {
     0 => {
       let [val_idx_obj, cases_obj, default_obj] = ctor.objs::<3>();
@@ -268,7 +276,7 @@ fn decode_ctrl(ctor: LeanCtor<LeanBorrowed<'_>>) -> Ctrl {
   }
 }
 
-fn decode_block(ctor: LeanCtor<LeanBorrowed<'_>>) -> Block {
+fn decode_block<F: LeanField>(ctor: LeanCtor<LeanBorrowed<'_>>) -> Block<F> {
   let [ops_obj, ctrl_obj] = ctor.objs::<2>();
   let ops = ops_obj.as_array().map(|o| decode_op(o.as_ctor()));
   let ctrl = decode_ctrl(ctrl_obj.as_ctor());
@@ -285,7 +293,9 @@ fn decode_function_layout(ctor: LeanCtor<LeanBorrowed<'_>>) -> FunctionLayout {
   }
 }
 
-fn decode_function(ctor: LeanCtor<LeanBorrowed<'_>>) -> Function {
+fn decode_function<F: LeanField>(
+  ctor: LeanCtor<LeanBorrowed<'_>>,
+) -> Function<F> {
   let ctor = LeanAiurFunction::from_ctor(ctor);
   let body = decode_block(ctor.get_obj(0).as_ctor());
   let layout = decode_function_layout(ctor.get_obj(1).as_ctor());
@@ -294,9 +304,9 @@ fn decode_function(ctor: LeanCtor<LeanBorrowed<'_>>) -> Function {
   Function { body, layout, entry, constrained }
 }
 
-pub(crate) fn decode_toplevel(
+pub(crate) fn decode_toplevel<F: LeanField>(
   obj: &LeanAiurToplevel<impl LeanRef>,
-) -> Toplevel {
+) -> Toplevel<F> {
   let ctor = obj.as_ctor();
   let [functions_obj, memory_sizes_obj] = ctor.objs::<2>();
   let functions =
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs
index 051a10e1..75ebca19 100644
--- a/crates/ixvm-codegen/src/aiur_multi_stark.rs
+++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs
@@ -588,8 +588,8 @@ fn aiur_fn_10(
   })
 }
 
-const INPUT_SIZE_11: usize = 8;
-const IN_11: usize = 8;
+const INPUT_SIZE_11: usize = 0;
+const IN_11: usize = 0;
 const OUT_11: usize = 1;
 fn aiur_fn_11(
   inp: [G; IN_11],
@@ -597,6 +597,237 @@ fn aiur_fn_11(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_11], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(0);
+    let __ret: [G; OUT_11] = [__v_0];
+    if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_12: usize = 0;
+const IN_12: usize = 0;
+const OUT_12: usize = 1;
+fn aiur_fn_12(
+  inp: [G; IN_12],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_12], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(1);
+    let __ret: [G; OUT_12] = [__v_0];
+    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_13: usize = 0;
+const IN_13: usize = 0;
+const OUT_13: usize = 1;
+fn aiur_fn_13(
+  inp: [G; IN_13],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_13], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(2);
+    let __ret: [G; OUT_13] = [__v_0];
+    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_14: usize = 0;
+const IN_14: usize = 0;
+const OUT_14: usize = 1;
+fn aiur_fn_14(
+  inp: [G; IN_14],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_14], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(7);
+    let __ret: [G; OUT_14] = [__v_0];
+    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_15: usize = 0;
+const IN_15: usize = 0;
+const OUT_15: usize = 1;
+fn aiur_fn_15(
+  inp: [G; IN_15],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_15], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(1753635133440165772);
+    let __ret: [G; OUT_15] = [__v_0];
+    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_16: usize = 2;
+const IN_16: usize = 2;
+const OUT_16: usize = 1;
+fn aiur_fn_16(
+  inp: [G; IN_16],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_16], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(256);
+    let __v_3: G = (__v_2 * __v_1);
+    let __v_4: G = (__v_0 + __v_3);
+    let __ret: [G; OUT_16] = [__v_4];
+    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_17: usize = 2;
+const IN_17: usize = 2;
+const OUT_17: usize = 1;
+fn aiur_fn_17(
+  inp: [G; IN_17],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_17], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = (__v_0 + __v_1);
+    let __ret: [G; OUT_17] = [__v_2];
+    if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_18: usize = 2;
+const IN_18: usize = 2;
+const OUT_18: usize = 1;
+fn aiur_fn_18(
+  inp: [G; IN_18],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_18], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = (__v_0 - __v_1);
+    let __ret: [G; OUT_18] = [__v_2];
+    if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_19: usize = 1;
+const IN_19: usize = 1;
+const OUT_19: usize = 1;
+fn aiur_fn_19(
+  inp: [G; IN_19],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_19], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __v_2: G = (__v_1 - __v_0);
+    let __ret: [G; OUT_19] = [__v_2];
+    if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_20: usize = 2;
+const IN_20: usize = 2;
+const OUT_20: usize = 1;
+fn aiur_fn_20(
+  inp: [G; IN_20],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_20], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = (__v_0 * __v_1);
+    let __ret: [G; OUT_20] = [__v_2];
+    if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_21: usize = 1;
+const IN_21: usize = 1;
+const OUT_21: usize = 1;
+fn aiur_fn_21(
+  inp: [G; IN_21],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_21], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_bool((__v_0 == G::ZERO));
+    let __ret: [G; OUT_21] = [__v_1];
+    if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_22: usize = 1;
+const IN_22: usize = 1;
+const OUT_22: usize = 1;
+fn aiur_fn_22(
+  inp: [G; IN_22],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_22], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = g_inverse_value(__v_0);
+    let __v_2: G = (__v_0 * __v_1);
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_2 - __v_3);
+    let __v_5: G = (__v_0 * __v_4);
+    let __v_6: G = G::from_u64(0);
+    if (__v_5 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
+    }
+    let __v_7: G = (__v_1 * __v_4);
+    let __v_8: G = G::from_u64(0);
+    if (__v_7 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_22] = [__v_1];
+    if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_23: usize = 8;
+const IN_23: usize = 8;
+const OUT_23: usize = 1;
+fn aiur_fn_23(
+  inp: [G; IN_23],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_23], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -627,21 +858,21 @@ fn aiur_fn_11(
     let __v_26: G = (__v_11 + __v_25);
     let __v_27: G = (__v_9 + __v_26);
     let __v_28: G = (__v_0 + __v_27);
-    let __ret: [G; OUT_11] = [__v_28];
-    if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_23] = [__v_28];
+    if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_12: usize = 8;
-const IN_12: usize = 8;
-const OUT_12: usize = 1;
-fn aiur_fn_12(
-  inp: [G; IN_12],
+const INPUT_SIZE_24: usize = 8;
+const IN_24: usize = 8;
+const OUT_24: usize = 1;
+fn aiur_fn_24(
+  inp: [G; IN_24],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_12], ExecError> {
+) -> Result<[G; OUT_24], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -666,21 +897,21 @@ fn aiur_fn_12(
     let __v_20: G = (__v_19 - __v_17);
     let __v_21: G = (__v_13 * __v_20);
     let __v_22: G = (__v_18 - __v_21);
-    let __ret: [G; OUT_12] = [__v_22];
-    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_24] = [__v_22];
+    if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_13: usize = 1;
-const IN_13: usize = 1;
-const OUT_13: usize = 8;
-fn aiur_fn_13(
-  inp: [G; IN_13],
+const INPUT_SIZE_25: usize = 1;
+const IN_25: usize = 1;
+const OUT_25: usize = 8;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_13], ExecError> {
+) -> Result<[G; OUT_25], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
@@ -739,52 +970,21 @@ fn aiur_fn_13(
     if (__v_44 != __v_45) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None });
     }
-    let __ret: [G; OUT_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_14: usize = 1;
-const IN_14: usize = 1;
-const OUT_14: usize = 1;
-fn aiur_fn_14(
-  inp: [G; IN_14],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_14], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = g_inverse_value(__v_0);
-    let __v_2: G = (__v_0 * __v_1);
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = (__v_2 - __v_3);
-    let __v_5: G = (__v_0 * __v_4);
-    let __v_6: G = G::from_u64(0);
-    if (__v_5 != __v_6) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
-    }
-    let __v_7: G = (__v_1 * __v_4);
-    let __v_8: G = G::from_u64(0);
-    if (__v_7 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
-    }
-    let __ret: [G; OUT_14] = [__v_1];
-    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_25] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_15: usize = 4;
-const IN_15: usize = 4;
-const OUT_15: usize = 2;
-fn aiur_fn_15(
-  inp: [G; IN_15],
+const INPUT_SIZE_26: usize = 4;
+const IN_26: usize = 4;
+const OUT_26: usize = 2;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
+) -> Result<[G; OUT_26], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -792,21 +992,21 @@ fn aiur_fn_15(
     let __v_3: G = inp[3];
     let __v_4: G = (__v_0 + __v_2);
     let __v_5: G = (__v_1 + __v_3);
-    let __ret: [G; OUT_15] = [__v_4, __v_5];
-    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_26] = [__v_4, __v_5];
+    if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_16: usize = 4;
-const IN_16: usize = 4;
-const OUT_16: usize = 2;
-fn aiur_fn_16(
-  inp: [G; IN_16],
+const INPUT_SIZE_27: usize = 4;
+const IN_27: usize = 4;
+const OUT_27: usize = 2;
+fn aiur_fn_27(
+  inp: [G; IN_27],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_16], ExecError> {
+) -> Result<[G; OUT_27], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -814,21 +1014,21 @@ fn aiur_fn_16(
     let __v_3: G = inp[3];
     let __v_4: G = (__v_0 - __v_2);
     let __v_5: G = (__v_1 - __v_3);
-    let __ret: [G; OUT_16] = [__v_4, __v_5];
-    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_27] = [__v_4, __v_5];
+    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_17: usize = 2;
-const IN_17: usize = 2;
-const OUT_17: usize = 2;
-fn aiur_fn_17(
-  inp: [G; IN_17],
+const INPUT_SIZE_28: usize = 2;
+const IN_28: usize = 2;
+const OUT_28: usize = 2;
+fn aiur_fn_28(
+  inp: [G; IN_28],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], ExecError> {
+) -> Result<[G; OUT_28], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -836,21 +1036,21 @@ fn aiur_fn_17(
     let __v_3: G = (__v_2 - __v_0);
     let __v_4: G = G::from_u64(0);
     let __v_5: G = (__v_4 - __v_1);
-    let __ret: [G; OUT_17] = [__v_3, __v_5];
-    if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_28] = [__v_3, __v_5];
+    if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_18: usize = 4;
-const IN_18: usize = 4;
-const OUT_18: usize = 2;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_29: usize = 4;
+const IN_29: usize = 4;
+const OUT_29: usize = 2;
+fn aiur_fn_29(
+  inp: [G; IN_29],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], ExecError> {
+) -> Result<[G; OUT_29], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -860,25 +1060,25 @@ fn aiur_fn_18(
     let __v_5: G = G::from_u64(7);
     let __v_6: G = (__v_1 * __v_3);
     let __v_7: G = (__v_5 * __v_6);
-    let __v_8: G = (__v_4 + __v_7);
-    let __v_9: G = (__v_0 * __v_3);
-    let __v_10: G = (__v_1 * __v_2);
-    let __v_11: G = (__v_9 + __v_10);
-    let __ret: [G; OUT_18] = [__v_8, __v_11];
-    if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_8: G = (__v_0 * __v_3);
+    let __v_9: G = (__v_1 * __v_2);
+    let __v_10: G = (__v_4 + __v_7);
+    let __v_11: G = (__v_8 + __v_9);
+    let __ret: [G; OUT_29] = [__v_10, __v_11];
+    if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_19: usize = 2;
-const IN_19: usize = 2;
-const OUT_19: usize = 2;
-fn aiur_fn_19(
-  inp: [G; IN_19],
+const INPUT_SIZE_30: usize = 2;
+const IN_30: usize = 2;
+const OUT_30: usize = 2;
+fn aiur_fn_30(
+  inp: [G; IN_30],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_19], ExecError> {
+) -> Result<[G; OUT_30], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -901,25 +1101,25 @@ fn aiur_fn_19(
     if (__v_13 != __v_14) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
     }
-    let __v_15: G = (__v_0 * __v_7);
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = (__v_16 - __v_1);
-    let __v_18: G = (__v_17 * __v_7);
-    let __ret: [G; OUT_19] = [__v_15, __v_18];
-    if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = (__v_15 - __v_1);
+    let __v_17: G = (__v_0 * __v_7);
+    let __v_18: G = (__v_16 * __v_7);
+    let __ret: [G; OUT_30] = [__v_17, __v_18];
+    if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_20: usize = 4;
-const IN_20: usize = 4;
-const OUT_20: usize = 2;
-fn aiur_fn_20(
-  inp: [G; IN_20],
+const INPUT_SIZE_31: usize = 4;
+const IN_31: usize = 4;
+const OUT_31: usize = 2;
+fn aiur_fn_31(
+  inp: [G; IN_31],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_20], ExecError> {
+) -> Result<[G; OUT_31], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -944,886 +1144,594 @@ fn aiur_fn_20(
     if (__v_15 != __v_16) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
     }
-    let __v_17: G = (__v_2 * __v_9);
-    let __v_18: G = G::from_u64(0);
-    let __v_19: G = (__v_18 - __v_3);
-    let __v_20: G = (__v_19 * __v_9);
-    let __v_21: G = (__v_0 * __v_17);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = (__v_17 - __v_3);
+    let __v_19: G = (__v_2 * __v_9);
+    let __v_20: G = (__v_18 * __v_9);
+    let __v_21: G = (__v_0 * __v_19);
     let __v_22: G = G::from_u64(7);
     let __v_23: G = (__v_1 * __v_20);
     let __v_24: G = (__v_22 * __v_23);
-    let __v_25: G = (__v_21 + __v_24);
-    let __v_26: G = (__v_0 * __v_20);
-    let __v_27: G = (__v_1 * __v_17);
-    let __v_28: G = (__v_26 + __v_27);
-    let __ret: [G; OUT_20] = [__v_25, __v_28];
-    if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_25: G = (__v_0 * __v_20);
+    let __v_26: G = (__v_1 * __v_19);
+    let __v_27: G = (__v_21 + __v_24);
+    let __v_28: G = (__v_25 + __v_26);
+    let __ret: [G; OUT_31] = [__v_27, __v_28];
+    if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_21: usize = 4;
-const IN_21: usize = 4;
-const OUT_21: usize = 1;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_32: usize = 4;
+const IN_32: usize = 4;
+const OUT_32: usize = 1;
+fn aiur_fn_32(
+  inp: [G; IN_32],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_21], ExecError> {
+) -> Result<[G; OUT_32], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = (__v_0 - __v_2);
-    let __v_5: G = G::from_bool((__v_4 == G::ZERO));
-    let __v_6: G = (__v_1 - __v_3);
-    let __v_7: G = G::from_bool((__v_6 == G::ZERO));
-    let __v_8: G = (__v_5 * __v_7);
-    let __ret: [G; OUT_21] = [__v_8];
-    if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_22: usize = 1;
-const IN_22: usize = 1;
-const OUT_22: usize = 2;
-fn aiur_fn_22(
-  inp: [G; IN_22],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_22], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_22] = [__v_2, __v_3];
-        if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_22] = [__v_4, __v_7];
-        if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_23: usize = 1;
-const IN_23: usize = 1;
-const OUT_23: usize = 9;
-fn aiur_fn_23(
-  inp: [G; IN_23],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = __r_arr[1];
-    let __ret: [G; OUT_23] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
-    if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_24: usize = 1;
-const IN_24: usize = 1;
-const OUT_24: usize = 2;
-fn aiur_fn_24(
-  inp: [G; IN_24],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_24], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __ret: [G; OUT_24] = [__v_10, __v_9];
-    if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_5: G = (__v_1 - __v_3);
+    let __v_6: G = G::from_bool((__v_4 == G::ZERO));
+    let __v_7: G = G::from_bool((__v_5 == G::ZERO));
+    let __v_8: G = (__v_6 * __v_7);
+    let __ret: [G; OUT_32] = [__v_8];
+    if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_25: usize = 1;
-const IN_25: usize = 1;
-const OUT_25: usize = 2;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_33: usize = 9;
+const IN_33: usize = 9;
+const OUT_33: usize = 1;
+fn aiur_fn_33(
+  inp: [G; IN_33],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_25], ExecError> {
+) -> Result<[G; OUT_33], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
-    let __v_2: G = __io_read[0];
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = (__v_0 + __v_3);
-    let __ret: [G; OUT_25] = [__v_2, __v_4];
-    if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_33] = [__v_24];
+    if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_26: usize = 1;
-const IN_26: usize = 1;
-const OUT_26: usize = 9;
-fn aiur_fn_26(
-  inp: [G; IN_26],
+const INPUT_SIZE_34: usize = 2;
+const IN_34: usize = 2;
+const OUT_34: usize = 1;
+fn aiur_fn_34(
+  inp: [G; IN_34],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_26], ExecError> {
+) -> Result<[G; OUT_34], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr };
-    let __v_2: G = __io_read[0];
-    let __v_3: G = __io_read[1];
-    let __v_4: G = __io_read[2];
-    let __v_5: G = __io_read[3];
-    let __v_6: G = __io_read[4];
-    let __v_7: G = __io_read[5];
-    let __v_8: G = __io_read[6];
-    let __v_9: G = __io_read[7];
-    let __v_10: G = G::from_u64(8);
-    let __v_11: G = (__v_0 + __v_10);
-    let __ret: [G; OUT_26] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
-    if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_34] = [__v_1];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __ret: [G; OUT_34] = [__v_13];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_27: usize = 1;
-const IN_27: usize = 1;
-const OUT_27: usize = 2;
-fn aiur_fn_27(
-  inp: [G; IN_27],
+const INPUT_SIZE_35: usize = 2;
+const IN_35: usize = 2;
+const OUT_35: usize = 1;
+fn aiur_fn_35(
+  inp: [G; IN_35],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], ExecError> {
+) -> Result<[G; OUT_35], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __ret: [G; OUT_27] = [__v_10, __v_9];
-    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_35] = [__v_1];
+        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_35] = [__v_7];
+        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_28: usize = 1;
-const IN_28: usize = 1;
-const OUT_28: usize = 3;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_36: usize = 2;
+const IN_36: usize = 2;
+const OUT_36: usize = 10;
+fn aiur_fn_36(
+  inp: [G; IN_36],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = __r_arr[1];
-    let __v_12: G = __r_arr[2];
-    let __v_13: G = __r_arr[3];
-    let __v_14: G = __r_arr[4];
-    let __v_15: G = __r_arr[5];
-    let __v_16: G = __r_arr[6];
-    let __v_17: G = __r_arr[7];
-    let __v_18: G = __r_arr[8];
-    let __v_19: G = G::from_u64(256);
-    let __v_20: G = (__v_19 * __v_2);
-    let __v_21: G = G::from_u64(65536);
-    let __v_22: G = (__v_21 * __v_3);
-    let __v_23: G = G::from_u64(16777216);
-    let __v_24: G = (__v_23 * __v_4);
-    let __v_25: G = G::from_u64(4294967296);
-    let __v_26: G = (__v_25 * __v_5);
-    let __v_27: G = G::from_u64(1099511627776);
-    let __v_28: G = (__v_27 * __v_6);
-    let __v_29: G = G::from_u64(281474976710656);
-    let __v_30: G = (__v_29 * __v_7);
-    let __v_31: G = G::from_u64(72057594037927936);
-    let __v_32: G = (__v_31 * __v_8);
-    let __v_33: G = (__v_30 + __v_32);
-    let __v_34: G = (__v_28 + __v_33);
-    let __v_35: G = (__v_26 + __v_34);
-    let __v_36: G = (__v_24 + __v_35);
-    let __v_37: G = (__v_22 + __v_36);
-    let __v_38: G = (__v_20 + __v_37);
-    let __v_39: G = (__v_1 + __v_38);
-    let __v_40: G = G::from_u64(256);
-    let __v_41: G = (__v_40 * __v_11);
-    let __v_42: G = G::from_u64(65536);
-    let __v_43: G = (__v_42 * __v_12);
-    let __v_44: G = G::from_u64(16777216);
-    let __v_45: G = (__v_44 * __v_13);
-    let __v_46: G = G::from_u64(4294967296);
-    let __v_47: G = (__v_46 * __v_14);
-    let __v_48: G = G::from_u64(1099511627776);
-    let __v_49: G = (__v_48 * __v_15);
-    let __v_50: G = G::from_u64(281474976710656);
-    let __v_51: G = (__v_50 * __v_16);
-    let __v_52: G = G::from_u64(72057594037927936);
-    let __v_53: G = (__v_52 * __v_17);
-    let __v_54: G = (__v_51 + __v_53);
-    let __v_55: G = (__v_49 + __v_54);
-    let __v_56: G = (__v_47 + __v_55);
-    let __v_57: G = (__v_45 + __v_56);
-    let __v_58: G = (__v_43 + __v_57);
-    let __v_59: G = (__v_41 + __v_58);
-    let __v_60: G = (__v_10 + __v_59);
-    let __ret: [G; OUT_28] = [__v_39, __v_60, __v_18];
-    if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_29: usize = 1;
-const IN_29: usize = 1;
-const OUT_29: usize = 33;
-fn aiur_fn_29(
-  inp: [G; IN_29],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_29], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = __r_arr[1];
-    let __v_12: G = __r_arr[2];
-    let __v_13: G = __r_arr[3];
-    let __v_14: G = __r_arr[4];
-    let __v_15: G = __r_arr[5];
-    let __v_16: G = __r_arr[6];
-    let __v_17: G = __r_arr[7];
-    let __v_18: G = __r_arr[8];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __v_20: G = __r_arr[1];
-    let __v_21: G = __r_arr[2];
-    let __v_22: G = __r_arr[3];
-    let __v_23: G = __r_arr[4];
-    let __v_24: G = __r_arr[5];
-    let __v_25: G = __r_arr[6];
-    let __v_26: G = __r_arr[7];
-    let __v_27: G = __r_arr[8];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-    let __v_28: G = __r_arr[0];
-    let __v_29: G = __r_arr[1];
-    let __v_30: G = __r_arr[2];
-    let __v_31: G = __r_arr[3];
-    let __v_32: G = __r_arr[4];
-    let __v_33: G = __r_arr[5];
-    let __v_34: G = __r_arr[6];
-    let __v_35: G = __r_arr[7];
-    let __v_36: G = __r_arr[8];
-    let __ret: [G; OUT_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-    if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_30: usize = 1;
-const IN_30: usize = 1;
-const OUT_30: usize = 2;
-fn aiur_fn_30(
-  inp: [G; IN_30],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_30], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_30] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_31: usize = 2;
-const IN_31: usize = 2;
-const OUT_31: usize = 2;
-fn aiur_fn_31(
-  inp: [G; IN_31],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_31], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_31] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_31] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_32: usize = 1;
-const IN_32: usize = 1;
-const OUT_32: usize = 2;
-fn aiur_fn_32(
-  inp: [G; IN_32],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_32], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_32] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_33: usize = 2;
-const IN_33: usize = 2;
-const OUT_33: usize = 2;
-fn aiur_fn_33(
-  inp: [G; IN_33],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_33], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_33] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = __r_arr[2];
-        let __v_5: G = __r_arr[3];
-        let __v_6: G = __r_arr[4];
-        let __v_7: G = __r_arr[5];
-        let __v_8: G = __r_arr[6];
-        let __v_9: G = __r_arr[7];
-        let __v_10: G = __r_arr[8];
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = (__v_1 - __v_11);
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_33] = [__v_16, __v_14];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_34: usize = 1;
-const IN_34: usize = 1;
-const OUT_34: usize = 2;
-fn aiur_fn_34(
-  inp: [G; IN_34],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_34], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_34] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_35: usize = 2;
-const IN_35: usize = 2;
-const OUT_35: usize = 2;
-fn aiur_fn_35(
-  inp: [G; IN_35],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_35], ExecError> {
+) -> Result<[G; OUT_36], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_35] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = __r_arr[2];
-        let __v_5: G = __r_arr[3];
-        let __v_6: G = __r_arr[4];
-        let __v_7: G = __r_arr[5];
-        let __v_8: G = __r_arr[6];
-        let __v_9: G = __r_arr[7];
-        let __v_10: G = __r_arr[8];
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __v_13: G = __r_arr[2];
-        let __v_14: G = __r_arr[3];
-        let __v_15: G = __r_arr[4];
-        let __v_16: G = __r_arr[5];
-        let __v_17: G = __r_arr[6];
-        let __v_18: G = __r_arr[7];
-        let __v_19: G = __r_arr[8];
-        let __v_20: G = G::from_u64(256);
-        let __v_21: G = (__v_20 * __v_3);
-        let __v_22: G = G::from_u64(65536);
-        let __v_23: G = (__v_22 * __v_4);
-        let __v_24: G = G::from_u64(16777216);
-        let __v_25: G = (__v_24 * __v_5);
-        let __v_26: G = G::from_u64(4294967296);
-        let __v_27: G = (__v_26 * __v_6);
-        let __v_28: G = G::from_u64(1099511627776);
-        let __v_29: G = (__v_28 * __v_7);
-        let __v_30: G = G::from_u64(281474976710656);
-        let __v_31: G = (__v_30 * __v_8);
-        let __v_32: G = G::from_u64(72057594037927936);
-        let __v_33: G = (__v_32 * __v_9);
-        let __v_34: G = (__v_31 + __v_33);
-        let __v_35: G = (__v_29 + __v_34);
-        let __v_36: G = (__v_27 + __v_35);
-        let __v_37: G = (__v_25 + __v_36);
-        let __v_38: G = (__v_23 + __v_37);
-        let __v_39: G = (__v_21 + __v_38);
-        let __v_40: G = (__v_2 + __v_39);
-        let __v_41: G = G::from_u64(256);
-        let __v_42: G = (__v_41 * __v_12);
-        let __v_43: G = G::from_u64(65536);
-        let __v_44: G = (__v_43 * __v_13);
-        let __v_45: G = G::from_u64(16777216);
-        let __v_46: G = (__v_45 * __v_14);
-        let __v_47: G = G::from_u64(4294967296);
-        let __v_48: G = (__v_47 * __v_15);
-        let __v_49: G = G::from_u64(1099511627776);
-        let __v_50: G = (__v_49 * __v_16);
-        let __v_51: G = G::from_u64(281474976710656);
-        let __v_52: G = (__v_51 * __v_17);
-        let __v_53: G = G::from_u64(72057594037927936);
-        let __v_54: G = (__v_53 * __v_18);
-        let __v_55: G = (__v_52 + __v_54);
-        let __v_56: G = (__v_50 + __v_55);
-        let __v_57: G = (__v_48 + __v_56);
-        let __v_58: G = (__v_46 + __v_57);
-        let __v_59: G = (__v_44 + __v_58);
-        let __v_60: G = (__v_42 + __v_59);
-        let __v_61: G = (__v_11 + __v_60);
-        let __v_62: G = G::from_u64(1);
-        let __v_63: G = (__v_1 - __v_62);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
-        let __v_64: G = __r_arr[0];
-        let __v_65: G = __r_arr[1];
-        let __v_66: G = G::from_u64(0);
-        let __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_35] = [__v_67, __v_65];
-        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_36: usize = 1;
-const IN_36: usize = 1;
-const OUT_36: usize = 2;
-fn aiur_fn_36(
-  inp: [G; IN_36],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_36], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_36] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_37: usize = 2;
-const IN_37: usize = 2;
-const OUT_37: usize = 2;
-fn aiur_fn_37(
-  inp: [G; IN_37],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_37], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_37] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = __r_arr[2];
-        let __v_5: G = __r_arr[3];
-        let __v_6: G = __r_arr[4];
-        let __v_7: G = __r_arr[5];
-        let __v_8: G = __r_arr[6];
-        let __v_9: G = __r_arr[7];
-        let __v_10: G = __r_arr[8];
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __v_13: G = __r_arr[2];
-        let __v_14: G = __r_arr[3];
-        let __v_15: G = __r_arr[4];
-        let __v_16: G = __r_arr[5];
-        let __v_17: G = __r_arr[6];
-        let __v_18: G = __r_arr[7];
-        let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_19]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        let __v_22: G = __r_arr[2];
-        let __v_23: G = __r_arr[3];
-        let __v_24: G = __r_arr[4];
-        let __v_25: G = __r_arr[5];
-        let __v_26: G = __r_arr[6];
-        let __v_27: G = __r_arr[7];
-        let __v_28: G = __r_arr[8];
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
-        let __v_31: G = __r_arr[2];
-        let __v_32: G = __r_arr[3];
-        let __v_33: G = __r_arr[4];
-        let __v_34: G = __r_arr[5];
-        let __v_35: G = __r_arr[6];
-        let __v_36: G = __r_arr[7];
-        let __v_37: G = __r_arr[8];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(103);
+        let __v_6: G = G::from_u64(230);
+        let __v_7: G = G::from_u64(9);
+        let __v_8: G = G::from_u64(106);
+        let __v_9: G = G::from_u64(133);
+        let __v_10: G = G::from_u64(174);
+        let __v_11: G = G::from_u64(103);
+        let __v_12: G = G::from_u64(187);
+        let __v_13: G = G::from_u64(114);
+        let __v_14: G = G::from_u64(243);
+        let __v_15: G = G::from_u64(110);
+        let __v_16: G = G::from_u64(60);
+        let __v_17: G = G::from_u64(58);
+        let __v_18: G = G::from_u64(245);
+        let __v_19: G = G::from_u64(79);
+        let __v_20: G = G::from_u64(165);
+        let __v_21: G = G::from_u64(127);
+        let __v_22: G = G::from_u64(82);
+        let __v_23: G = G::from_u64(14);
+        let __v_24: G = G::from_u64(81);
+        let __v_25: G = G::from_u64(140);
+        let __v_26: G = G::from_u64(104);
+        let __v_27: G = G::from_u64(5);
+        let __v_28: G = G::from_u64(155);
+        let __v_29: G = G::from_u64(171);
+        let __v_30: G = G::from_u64(217);
+        let __v_31: G = G::from_u64(131);
+        let __v_32: G = G::from_u64(31);
+        let __v_33: G = G::from_u64(25);
+        let __v_34: G = G::from_u64(205);
+        let __v_35: G = G::from_u64(224);
+        let __v_36: G = G::from_u64(91);
+        let __v_37: G = G::from_u64(1);
         let __v_38: G = G::from_u64(1);
-        let __v_39: G = (__v_1 - __v_38);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
-        let __v_40: G = __r_arr[0];
-        let __v_41: G = __r_arr[1];
+        let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_40: G = G::from_u64(0);
+        let __v_41: G = G::from_u64(0);
         let __v_42: G = G::from_u64(0);
-        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_37] = [__v_44, __v_41];
-        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_38: usize = 1;
-const IN_38: usize = 1;
-const OUT_38: usize = 2;
-fn aiur_fn_38(
-  inp: [G; IN_38],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_38], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_38] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_39: usize = 2;
-const IN_39: usize = 2;
-const OUT_39: usize = 2;
-fn aiur_fn_39(
-  inp: [G; IN_39],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_39], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_39] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_39] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_40: usize = 1;
-const IN_40: usize = 1;
-const OUT_40: usize = 2;
-fn aiur_fn_40(
-  inp: [G; IN_40],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_40], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_40] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+        let __v_43: G = G::from_u64(0);
+        let __v_44: G = G::from_u64(0);
+        let __v_45: G = G::from_u64(0);
+        let __v_46: G = G::from_u64(0);
+        let __v_47: G = G::from_u64(0);
+        let __v_48: G = G::from_u64(0);
+        let __v_49: G = G::from_u64(0);
+        let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_52: G = G::from_u64(1);
+        let __v_53: G = G::from_u64(1);
+        let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __v_56: G = __r_arr[0];
+        let __v_57: G = __r_arr[1];
+        let __v_58: G = __r_arr[2];
+        let __v_59: G = __r_arr[3];
+        let __v_60: G = __r_arr[4];
+        let __v_61: G = __r_arr[5];
+        let __v_62: G = __r_arr[6];
+        let __v_63: G = __r_arr[7];
+        let __v_64: G = __r_arr[8];
+        let __v_65: G = __r_arr[9];
+        let __v_66: G = __r_arr[10];
+        let __v_67: G = __r_arr[11];
+        let __v_68: G = __r_arr[12];
+        let __v_69: G = __r_arr[13];
+        let __v_70: G = __r_arr[14];
+        let __v_71: G = __r_arr[15];
+        let __v_72: G = __r_arr[16];
+        let __v_73: G = __r_arr[17];
+        let __v_74: G = __r_arr[18];
+        let __v_75: G = __r_arr[19];
+        let __v_76: G = __r_arr[20];
+        let __v_77: G = __r_arr[21];
+        let __v_78: G = __r_arr[22];
+        let __v_79: G = __r_arr[23];
+        let __v_80: G = __r_arr[24];
+        let __v_81: G = __r_arr[25];
+        let __v_82: G = __r_arr[26];
+        let __v_83: G = __r_arr[27];
+        let __v_84: G = __r_arr[28];
+        let __v_85: G = __r_arr[29];
+        let __v_86: G = __r_arr[30];
+        let __v_87: G = __r_arr[31];
+        let __v_88: G = G::from_u64(1);
+        let __v_89: G = G::from_u64(1);
+        let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __v_91: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __v_92: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __v_93: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __v_94: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __v_95: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __v_96: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __v_97: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __v_98: G = __r_arr[0];
+        let __v_99: G = G::from_u64(1);
+        let __v_100: G = G::from_u64(1);
+        let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __v_102: G = __r_arr[0];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_103: G = __loaded[0];
+        let __v_104: G = __loaded[1];
+        let __v_105: G = __loaded[2];
+        match __v_103.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_106: G = __loaded[0];
+            let __v_107: G = __loaded[1];
+            let __v_108: G = __loaded[2];
+            match __v_106.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_109: G = __loaded[0];
+                let __v_110: G = __loaded[1];
+                let __v_111: G = __loaded[2];
+                match __v_109.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_112: G = __loaded[0];
+                    let __v_113: G = __loaded[1];
+                    let __v_114: G = __loaded[2];
+                    match __v_112.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_115: G = __loaded[0];
+                        let __v_116: G = __loaded[1];
+                        let __v_117: G = __loaded[2];
+                        match __v_115.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_118: G = __loaded[0];
+                            let __v_119: G = __loaded[1];
+                            let __v_120: G = __loaded[2];
+                            match __v_118.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_121: G = __loaded[0];
+                                let __v_122: G = __loaded[1];
+                                let __v_123: G = __loaded[2];
+                                match __v_121.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __v_124: G = __loaded[0];
+                                    let __v_125: G = __loaded[1];
+                                    let __v_126: G = __loaded[2];
+                                    match __v_124.as_canonical_u64() {
+                                      0u64 => {
+                                        let __ret: [G; OUT_36] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126];
+                                        if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+          },
+        }
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                match __v_11.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_14: G = __loaded[0];
+                    let __v_15: G = __loaded[1];
+                    let __v_16: G = __loaded[2];
+                    match __v_14.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_17: G = __loaded[0];
+                        let __v_18: G = __loaded[1];
+                        let __v_19: G = __loaded[2];
+                        match __v_17.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_20: G = __loaded[0];
+                            let __v_21: G = __loaded[1];
+                            let __v_22: G = __loaded[2];
+                            match __v_20.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_23: G = __loaded[0];
+                                let __v_24: G = __loaded[1];
+                                let __v_25: G = __loaded[2];
+                                match __v_23.as_canonical_u64() {
+                                  0u64 => {
+                                    let __ret: [G; OUT_36] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25];
+                                    if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_41: usize = 2;
-const IN_41: usize = 2;
-const OUT_41: usize = 2;
-fn aiur_fn_41(
-  inp: [G; IN_41],
+const INPUT_SIZE_37: usize = 2;
+const IN_37: usize = 2;
+const OUT_37: usize = 10;
+fn aiur_fn_37(
+  inp: [G; IN_37],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_41], ExecError> {
+) -> Result<[G; OUT_37], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_41] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_41] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = __r_arr[8];
+    let __v_11: G = __r_arr[9];
+    let __v_12: G = G::from_u64(1020);
+    let __v_13: G = (__v_9 - __v_12);
+    let __v_14: G = (__v_8 + __v_13);
+    let __v_15: G = (__v_7 + __v_14);
+    let __v_16: G = (__v_6 + __v_15);
+    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
+    let __v_18: G = (__v_4 + __v_5);
+    let __v_19: G = (__v_3 + __v_18);
+    let __v_20: G = (__v_2 + __v_19);
+    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
+    let __v_22: G = G::from_u64(1);
+    let __v_23: G = G::from_u64(1);
+    let __v_24: G = (__v_23 - __v_21);
+    let __v_25: G = (__v_17 * __v_24);
+    let __v_26: G = (__v_22 - __v_25);
+    match __v_26.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_37] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __v_28: G = __r_arr[1];
+        let __v_29: G = __r_arr[2];
+        let __v_30: G = __r_arr[3];
+        let __v_31: G = __r_arr[4];
+        let __v_32: G = __r_arr[5];
+        let __v_33: G = __r_arr[6];
+        let __v_34: G = __r_arr[7];
+        let __v_35: G = __r_arr[8];
+        let __v_36: G = __r_arr[9];
+        let __ret: [G; OUT_37] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_42: usize = 1;
-const IN_42: usize = 1;
-const OUT_42: usize = 2;
-fn aiur_fn_42(
-  inp: [G; IN_42],
+const INPUT_SIZE_38: usize = 2;
+const IN_38: usize = 2;
+const OUT_38: usize = 18;
+fn aiur_fn_38(
+  inp: [G; IN_38],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_42], ExecError> {
+) -> Result<[G; OUT_38], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_42] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = __r_arr[8];
+    let __v_11: G = __r_arr[9];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __v_13: G = __r_arr[1];
+    let __v_14: G = __r_arr[2];
+    let __v_15: G = __r_arr[3];
+    let __v_16: G = __r_arr[4];
+    let __v_17: G = __r_arr[5];
+    let __v_18: G = __r_arr[6];
+    let __v_19: G = __r_arr[7];
+    let __v_20: G = __r_arr[8];
+    let __v_21: G = __r_arr[9];
+    let __ret: [G; OUT_38] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+    if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_43: usize = 2;
-const IN_43: usize = 2;
-const OUT_43: usize = 2;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+const INPUT_SIZE_39: usize = 2;
+const IN_39: usize = 2;
+const OUT_39: usize = 1;
+fn aiur_fn_39(
+  inp: [G; IN_39],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_43], ExecError> {
+) -> Result<[G; OUT_39], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1832,477 +1740,971 @@ fn aiur_fn_43(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_43] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_39] = [__v_4];
+        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_43] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_39] = [__v_9];
+            if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_44: usize = 1;
-const IN_44: usize = 1;
-const OUT_44: usize = 2;
-fn aiur_fn_44(
-  inp: [G; IN_44],
+const INPUT_SIZE_40: usize = 3;
+const IN_40: usize = 3;
+const OUT_40: usize = 3;
+fn aiur_fn_40(
+  inp: [G; IN_40],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_44], ExecError> {
+) -> Result<[G; OUT_40], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __ret: [G; OUT_44] = [__v_1, __v_2];
-    if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = __r_arr[2];
+    let __v_6: G = __r_arr[3];
+    let __v_7: G = __r_arr[4];
+    let __v_8: G = __r_arr[5];
+    let __v_9: G = __r_arr[6];
+    let __v_10: G = __r_arr[7];
+    let __v_11: G = __r_arr[8];
+    let __v_12: G = __r_arr[9];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) };
+    let __v_13: G = __b1_out[0];
+    let __v_14: G = __b1_out[1];
+    let __v_15: G = __b1_out[2];
+    let __v_16: G = __b1_out[3];
+    let __v_17: G = __b1_out[4];
+    let __v_18: G = __b1_out[5];
+    let __v_19: G = __b1_out[6];
+    let __v_20: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) };
+    let __v_21: G = __b1_out[0];
+    let __v_22: G = __b1_out[1];
+    let __v_23: G = __b1_out[2];
+    let __v_24: G = __b1_out[3];
+    let __v_25: G = __b1_out[4];
+    let __v_26: G = __b1_out[5];
+    let __v_27: G = __b1_out[6];
+    let __v_28: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record) };
+    let __v_29: G = __b1_out[0];
+    let __v_30: G = __b1_out[1];
+    let __v_31: G = __b1_out[2];
+    let __v_32: G = __b1_out[3];
+    let __v_33: G = __b1_out[4];
+    let __v_34: G = __b1_out[5];
+    let __v_35: G = __b1_out[6];
+    let __v_36: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record) };
+    let __v_37: G = __b1_out[0];
+    let __v_38: G = __b1_out[1];
+    let __v_39: G = __b1_out[2];
+    let __v_40: G = __b1_out[3];
+    let __v_41: G = __b1_out[4];
+    let __v_42: G = __b1_out[5];
+    let __v_43: G = __b1_out[6];
+    let __v_44: G = __b1_out[7];
+    let __v_45: G = G::from_u64(1);
+    let __v_46: G = G::from_u64(1);
+    let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_48: G = __r_arr[0];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = __r_arr[0];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_50: G = __r_arr[0];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_52: G = __r_arr[0];
+    let __ret: [G; OUT_40] = [__v_52, __v_11, __v_12];
+    if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_45: usize = 1;
-const IN_45: usize = 1;
-const OUT_45: usize = 2;
-fn aiur_fn_45(
-  inp: [G; IN_45],
+const INPUT_SIZE_41: usize = 9;
+const IN_41: usize = 9;
+const OUT_41: usize = 1;
+fn aiur_fn_41(
+  inp: [G; IN_41],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_45], ExecError> {
+) -> Result<[G; OUT_41], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_45] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = G::from_u64(1);
+    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __ret: [G; OUT_41] = [__v_13];
+    if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_46: usize = 2;
-const IN_46: usize = 2;
-const OUT_46: usize = 2;
-fn aiur_fn_46(
-  inp: [G; IN_46],
+const INPUT_SIZE_42: usize = 2;
+const IN_42: usize = 2;
+const OUT_42: usize = 1;
+fn aiur_fn_42(
+  inp: [G; IN_42],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_46], ExecError> {
+) -> Result<[G; OUT_42], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_46] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_46] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_42] = [__v_1];
+        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
-    }
-  })
-}
-
-const INPUT_SIZE_47: usize = 1;
-const IN_47: usize = 1;
-const OUT_47: usize = 4;
-fn aiur_fn_47(
-  inp: [G; IN_47],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_47], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_47] = [__v_1, __v_3, __v_5, __v_6];
-    if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+      0u64 => {
+        let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
+        let __v_6: G = G::from_u8(__gb[0]);
+        let __v_7: G = G::from_u8(__gb[1]);
+        let __v_8: G = G::from_u8(__gb[2]);
+        let __v_9: G = G::from_u8(__gb[3]);
+        let __v_10: G = G::from_u8(__gb[4]);
+        let __v_11: G = G::from_u8(__gb[5]);
+        let __v_12: G = G::from_u8(__gb[6]);
+        let __v_13: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_14: G = G::from_u64(1020);
+        let __v_15: G = (__v_13 - __v_14);
+        let __v_16: G = (__v_12 + __v_15);
+        let __v_17: G = (__v_11 + __v_16);
+        let __v_18: G = (__v_10 + __v_17);
+        let __v_19: G = G::from_bool((__v_18 == G::ZERO));
+        let __v_20: G = (__v_8 + __v_9);
+        let __v_21: G = (__v_7 + __v_20);
+        let __v_22: G = (__v_6 + __v_21);
+        let __v_23: G = G::from_bool((__v_22 == G::ZERO));
+        let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes();
+        let __v_24: G = G::from_u8(__gb[0]);
+        let __v_25: G = G::from_u8(__gb[1]);
+        let __v_26: G = G::from_u8(__gb[2]);
+        let __v_27: G = G::from_u8(__gb[3]);
+        let __v_28: G = G::from_u8(__gb[4]);
+        let __v_29: G = G::from_u8(__gb[5]);
+        let __v_30: G = G::from_u8(__gb[6]);
+        let __v_31: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_30; let __vj = __v_31; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_32: G = G::from_u64(1020);
+        let __v_33: G = (__v_31 - __v_32);
+        let __v_34: G = (__v_30 + __v_33);
+        let __v_35: G = (__v_29 + __v_34);
+        let __v_36: G = (__v_28 + __v_35);
+        let __v_37: G = G::from_bool((__v_36 == G::ZERO));
+        let __v_38: G = (__v_26 + __v_27);
+        let __v_39: G = (__v_25 + __v_38);
+        let __v_40: G = (__v_24 + __v_39);
+        let __v_41: G = G::from_bool((__v_40 == G::ZERO));
+        let __v_42: G = G::from_u64(256);
+        let __v_43: G = (__v_42 * __v_7);
+        let __v_44: G = G::from_u64(65536);
+        let __v_45: G = (__v_44 * __v_8);
+        let __v_46: G = G::from_u64(16777216);
+        let __v_47: G = (__v_46 * __v_9);
+        let __v_48: G = G::from_u64(4294967296);
+        let __v_49: G = (__v_48 * __v_10);
+        let __v_50: G = G::from_u64(1099511627776);
+        let __v_51: G = (__v_50 * __v_11);
+        let __v_52: G = G::from_u64(281474976710656);
+        let __v_53: G = (__v_52 * __v_12);
+        let __v_54: G = G::from_u64(72057594037927936);
+        let __v_55: G = (__v_54 * __v_13);
+        let __v_56: G = (__v_53 + __v_55);
+        let __v_57: G = (__v_51 + __v_56);
+        let __v_58: G = (__v_49 + __v_57);
+        let __v_59: G = (__v_47 + __v_58);
+        let __v_60: G = (__v_45 + __v_59);
+        let __v_61: G = (__v_43 + __v_60);
+        let __v_62: G = (__v_6 + __v_61);
+        if (__v_62 != __v_3) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+        }
+        let __v_63: G = G::from_u64(1);
+        let __v_64: G = G::from_u64(1);
+        let __v_65: G = (__v_64 - __v_23);
+        let __v_66: G = (__v_19 * __v_65);
+        let __v_67: G = (__v_63 - __v_66);
+        let __v_68: G = G::from_u64(1);
+        if (__v_67 != __v_68) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: None });
+        }
+        let __v_69: G = G::from_u64(256);
+        let __v_70: G = (__v_69 * __v_25);
+        let __v_71: G = G::from_u64(65536);
+        let __v_72: G = (__v_71 * __v_26);
+        let __v_73: G = G::from_u64(16777216);
+        let __v_74: G = (__v_73 * __v_27);
+        let __v_75: G = G::from_u64(4294967296);
+        let __v_76: G = (__v_75 * __v_28);
+        let __v_77: G = G::from_u64(1099511627776);
+        let __v_78: G = (__v_77 * __v_29);
+        let __v_79: G = G::from_u64(281474976710656);
+        let __v_80: G = (__v_79 * __v_30);
+        let __v_81: G = G::from_u64(72057594037927936);
+        let __v_82: G = (__v_81 * __v_31);
+        let __v_83: G = (__v_80 + __v_82);
+        let __v_84: G = (__v_78 + __v_83);
+        let __v_85: G = (__v_76 + __v_84);
+        let __v_86: G = (__v_74 + __v_85);
+        let __v_87: G = (__v_72 + __v_86);
+        let __v_88: G = (__v_70 + __v_87);
+        let __v_89: G = (__v_24 + __v_88);
+        if (__v_89 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
+        }
+        let __v_90: G = G::from_u64(1);
+        let __v_91: G = G::from_u64(1);
+        let __v_92: G = (__v_91 - __v_41);
+        let __v_93: G = (__v_37 * __v_92);
+        let __v_94: G = (__v_90 - __v_93);
+        let __v_95: G = G::from_u64(1);
+        if (__v_94 != __v_95) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+        let __v_96: G = __r_arr[0];
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __v_97: G = __r_arr[0];
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __v_98: G = __r_arr[0];
+        let __ret: [G; OUT_42] = [__v_98];
+        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_48: usize = 1;
-const IN_48: usize = 1;
-const OUT_48: usize = 3;
-fn aiur_fn_48(
-  inp: [G; IN_48],
+const INPUT_SIZE_43: usize = 1;
+const IN_43: usize = 1;
+const OUT_43: usize = 1;
+fn aiur_fn_43(
+  inp: [G; IN_43],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_48], ExecError> {
+) -> Result<[G; OUT_43], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_48] = [__v_3, __v_5, __v_6];
-    if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_1: G = G::from_u64(0);
+    let __v_2: G = G::from_u64(109);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = G::from_u64(117);
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(108);
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(116);
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(105);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(45);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(115);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(116);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = G::from_u64(97);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(114);
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(107);
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = G::from_u64(47);
+    let __v_25: G = G::from_u64(0);
+    let __v_26: G = G::from_u64(118);
+    let __v_27: G = G::from_u64(0);
+    let __v_28: G = G::from_u64(48);
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_43] = [__v_42];
+    if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_49: usize = 1;
-const IN_49: usize = 1;
-const OUT_49: usize = 2;
-fn aiur_fn_49(
-  inp: [G; IN_49],
+const INPUT_SIZE_44: usize = 2;
+const IN_44: usize = 2;
+const OUT_44: usize = 1;
+fn aiur_fn_44(
+  inp: [G; IN_44],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_49], ExecError> {
+) -> Result<[G; OUT_44], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_49] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_44] = [__v_1];
+        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __ret: [G; OUT_44] = [__v_13];
+        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_50: usize = 2;
-const IN_50: usize = 2;
-const OUT_50: usize = 2;
-fn aiur_fn_50(
-  inp: [G; IN_50],
+const INPUT_SIZE_45: usize = 3;
+const IN_45: usize = 3;
+const OUT_45: usize = 2;
+fn aiur_fn_45(
+  inp: [G; IN_45],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_50], ExecError> {
+) -> Result<[G; OUT_45], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_50] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_45] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 - __v_8);
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_50] = [__v_13, __v_11];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_3: G = (__v_0 * __v_0);
+        let __v_4: G = G::from_u64(7);
+        let __v_5: G = (__v_1 * __v_1);
+        let __v_6: G = (__v_4 * __v_5);
+        let __v_7: G = (__v_0 * __v_1);
+        let __v_8: G = (__v_1 * __v_0);
+        let __v_9: G = (__v_3 + __v_6);
+        let __v_10: G = (__v_7 + __v_8);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_2 - __v_11);
+        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __ret: [G; OUT_45] = [__v_13, __v_14];
+        if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_51: usize = 1;
-const IN_51: usize = 1;
-const OUT_51: usize = 4;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+const INPUT_SIZE_46: usize = 1;
+const IN_46: usize = 1;
+const OUT_46: usize = 1;
+fn aiur_fn_46(
+  inp: [G; IN_46],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_51], ExecError> {
+) -> Result<[G; OUT_46], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_51] = [__v_1, __v_3, __v_5, __v_6];
-    if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_46] = [__v_1];
+        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      32u64 => {
+        let __v_1: G = G::from_u64(1753635133440165772);
+        let __ret: [G; OUT_46] = [__v_1];
+        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(1);
+        let __v_2: G = (__v_0 + __v_1);
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = (__v_3 * __v_3);
+        let __ret: [G; OUT_46] = [__v_4];
+        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_52: usize = 1;
-const IN_52: usize = 1;
-const OUT_52: usize = 2;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+const INPUT_SIZE_47: usize = 3;
+const IN_47: usize = 3;
+const OUT_47: usize = 2;
+fn aiur_fn_47(
+  inp: [G; IN_47],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_52], ExecError> {
+) -> Result<[G; OUT_47], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_52] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = (__v_3 - __v_5);
+    let __v_8: G = (__v_4 - __v_6);
+    let __ret: [G; OUT_47] = [__v_7, __v_8];
+    if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_53: usize = 2;
-const IN_53: usize = 2;
-const OUT_53: usize = 2;
-fn aiur_fn_53(
-  inp: [G; IN_53],
+const INPUT_SIZE_48: usize = 1;
+const IN_48: usize = 1;
+const OUT_48: usize = 1;
+fn aiur_fn_48(
+  inp: [G; IN_48],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_53], ExecError> {
+) -> Result<[G; OUT_48], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_48] = [__v_1];
+        if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __v_1: G = G::from_u64(2);
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_0 - __v_2);
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 - __v_8);
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 5] = [__v_12, __v_2, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_13, __v_11];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_5: G = (__v_1 * __v_4);
+        let __ret: [G; OUT_48] = [__v_5];
+        if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_54: usize = 1;
-const IN_54: usize = 1;
-const OUT_54: usize = 3;
-fn aiur_fn_54(
-  inp: [G; IN_54],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_54], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = __r_arr[1];
-    let __ret: [G; OUT_54] = [__v_3, __v_7, __v_8];
-    if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_55: usize = 1;
-const IN_55: usize = 1;
-const OUT_55: usize = 2;
-fn aiur_fn_55(
-  inp: [G; IN_55],
+const INPUT_SIZE_49: usize = 3;
+const IN_49: usize = 3;
+const OUT_49: usize = 8;
+fn aiur_fn_49(
+  inp: [G; IN_49],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_55], ExecError> {
+) -> Result<[G; OUT_49], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_55] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = (__v_3 - __v_5);
+    let __v_8: G = (__v_4 - __v_6);
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = g_inverse_value(__v_9);
+    let __v_11: G = (__v_9 * __v_10);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = (__v_11 - __v_12);
+    let __v_14: G = (__v_9 * __v_13);
+    let __v_15: G = G::from_u64(0);
+    if (__v_14 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
+    }
+    let __v_16: G = (__v_10 * __v_13);
+    let __v_17: G = G::from_u64(0);
+    if (__v_16 != __v_17) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
+    }
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = (__v_0 - __v_18);
+    let __v_21: G = (__v_1 - __v_19);
+    let __v_22: G = (__v_20 * __v_20);
+    let __v_23: G = G::from_u64(7);
+    let __v_24: G = (__v_21 * __v_21);
+    let __v_25: G = (__v_23 * __v_24);
+    let __v_26: G = (__v_22 - __v_25);
+    let __v_27: G = g_inverse_value(__v_26);
+    let __v_28: G = (__v_26 * __v_27);
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = (__v_28 - __v_29);
+    let __v_31: G = (__v_26 * __v_30);
+    let __v_32: G = G::from_u64(0);
+    if (__v_31 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+    }
+    let __v_33: G = (__v_27 * __v_30);
+    let __v_34: G = G::from_u64(0);
+    if (__v_33 != __v_34) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None });
+    }
+    let __v_35: G = G::from_u64(0);
+    let __v_36: G = (__v_35 - __v_21);
+    let __v_37: G = (__v_20 * __v_27);
+    let __v_38: G = (__v_36 * __v_27);
+    let __v_39: G = (__v_7 * __v_37);
+    let __v_40: G = G::from_u64(7);
+    let __v_41: G = (__v_8 * __v_38);
+    let __v_42: G = (__v_40 * __v_41);
+    let __v_43: G = (__v_7 * __v_38);
+    let __v_44: G = (__v_8 * __v_37);
+    let __v_45: G = (__v_39 + __v_42);
+    let __v_46: G = (__v_43 + __v_44);
+    let __v_47: G = G::from_u64(0);
+    let __v_48: G = (__v_0 - __v_10);
+    let __v_49: G = (__v_1 - __v_47);
+    let __v_50: G = (__v_48 * __v_48);
+    let __v_51: G = G::from_u64(7);
+    let __v_52: G = (__v_49 * __v_49);
+    let __v_53: G = (__v_51 * __v_52);
+    let __v_54: G = (__v_50 - __v_53);
+    let __v_55: G = g_inverse_value(__v_54);
+    let __v_56: G = (__v_54 * __v_55);
+    let __v_57: G = G::from_u64(1);
+    let __v_58: G = (__v_56 - __v_57);
+    let __v_59: G = (__v_54 * __v_58);
+    let __v_60: G = G::from_u64(0);
+    if (__v_59 != __v_60) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+    }
+    let __v_61: G = (__v_55 * __v_58);
+    let __v_62: G = G::from_u64(0);
+    if (__v_61 != __v_62) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
+    }
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = (__v_63 - __v_49);
+    let __v_65: G = (__v_48 * __v_55);
+    let __v_66: G = (__v_64 * __v_55);
+    let __v_67: G = (__v_7 * __v_65);
+    let __v_68: G = G::from_u64(7);
+    let __v_69: G = (__v_8 * __v_66);
+    let __v_70: G = (__v_68 * __v_69);
+    let __v_71: G = (__v_7 * __v_66);
+    let __v_72: G = (__v_8 * __v_65);
+    let __v_73: G = (__v_67 + __v_70);
+    let __v_74: G = (__v_71 + __v_72);
+    let __v_75: G = G::from_u64(0);
+    let __v_76: G = (__v_0 - __v_10);
+    let __v_77: G = (__v_1 - __v_75);
+    let __v_78: G = (__v_7 * __v_7);
+    let __v_79: G = G::from_u64(7);
+    let __v_80: G = (__v_8 * __v_8);
+    let __v_81: G = (__v_79 * __v_80);
+    let __v_82: G = (__v_78 - __v_81);
+    let __v_83: G = g_inverse_value(__v_82);
+    let __v_84: G = (__v_82 * __v_83);
+    let __v_85: G = G::from_u64(1);
+    let __v_86: G = (__v_84 - __v_85);
+    let __v_87: G = (__v_82 * __v_86);
+    let __v_88: G = G::from_u64(0);
+    if (__v_87 != __v_88) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
+    }
+    let __v_89: G = (__v_83 * __v_86);
+    let __v_90: G = G::from_u64(0);
+    if (__v_89 != __v_90) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: None });
+    }
+    let __v_91: G = G::from_u64(0);
+    let __v_92: G = (__v_91 - __v_8);
+    let __v_93: G = (__v_7 * __v_83);
+    let __v_94: G = (__v_92 * __v_83);
+    let __ret: [G; OUT_49] = [__v_45, __v_46, __v_73, __v_74, __v_76, __v_77, __v_93, __v_94];
+    if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_56: usize = 2;
-const IN_56: usize = 2;
-const OUT_56: usize = 2;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+const INPUT_SIZE_50: usize = 1;
+const IN_50: usize = 1;
+const OUT_50: usize = 2;
+fn aiur_fn_50(
+  inp: [G; IN_50],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_56], ExecError> {
+) -> Result<[G; OUT_50], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_56] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_50] = [__v_2, __v_3];
+        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_7, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = (__v_1 - __v_10);
-        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_14, __v_4, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_56] = [__v_15, __v_13];
-        if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_50] = [__v_4, __v_7];
+        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_57: usize = 1;
-const IN_57: usize = 1;
-const OUT_57: usize = 13;
-fn aiur_fn_57(
-  inp: [G; IN_57],
+const INPUT_SIZE_51: usize = 1;
+const IN_51: usize = 1;
+const OUT_51: usize = 9;
+fn aiur_fn_51(
+  inp: [G; IN_51],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_57], ExecError> {
+) -> Result<[G; OUT_51], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __v_15: G = __r_arr[2];
-    let __v_16: G = __r_arr[3];
-    let __v_17: G = __r_arr[4];
-    let __v_18: G = __r_arr[5];
-    let __v_19: G = __r_arr[6];
-    let __v_20: G = __r_arr[7];
-    let __v_21: G = __r_arr[8];
-    let __ret: [G; OUT_57] = [__v_3, __v_5, __v_9, __v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __ret: [G; OUT_51] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
+    if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_52: usize = 1;
+const IN_52: usize = 1;
+const OUT_52: usize = 2;
+fn aiur_fn_52(
+  inp: [G; IN_52],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_52], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __ret: [G; OUT_52] = [__v_10, __v_9];
+    if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_53: usize = 1;
+const IN_53: usize = 1;
+const OUT_53: usize = 2;
+fn aiur_fn_53(
+  inp: [G; IN_53],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_53], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_0 + __v_3);
+    let __ret: [G; OUT_53] = [__v_2, __v_4];
+    if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_54: usize = 1;
+const IN_54: usize = 1;
+const OUT_54: usize = 9;
+fn aiur_fn_54(
+  inp: [G; IN_54],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_54], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = __io_read[1];
+    let __v_4: G = __io_read[2];
+    let __v_5: G = __io_read[3];
+    let __v_6: G = __io_read[4];
+    let __v_7: G = __io_read[5];
+    let __v_8: G = __io_read[6];
+    let __v_9: G = __io_read[7];
+    let __v_10: G = G::from_u64(8);
+    let __v_11: G = (__v_0 + __v_10);
+    let __ret: [G; OUT_54] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
+    if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_55: usize = 1;
+const IN_55: usize = 1;
+const OUT_55: usize = 2;
+fn aiur_fn_55(
+  inp: [G; IN_55],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_55], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __ret: [G; OUT_55] = [__v_10, __v_9];
+    if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_56: usize = 1;
+const IN_56: usize = 1;
+const OUT_56: usize = 3;
+fn aiur_fn_56(
+  inp: [G; IN_56],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_56], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __v_19: G = G::from_u64(256);
+    let __v_20: G = (__v_19 * __v_2);
+    let __v_21: G = G::from_u64(65536);
+    let __v_22: G = (__v_21 * __v_3);
+    let __v_23: G = G::from_u64(16777216);
+    let __v_24: G = (__v_23 * __v_4);
+    let __v_25: G = G::from_u64(4294967296);
+    let __v_26: G = (__v_25 * __v_5);
+    let __v_27: G = G::from_u64(1099511627776);
+    let __v_28: G = (__v_27 * __v_6);
+    let __v_29: G = G::from_u64(281474976710656);
+    let __v_30: G = (__v_29 * __v_7);
+    let __v_31: G = G::from_u64(72057594037927936);
+    let __v_32: G = (__v_31 * __v_8);
+    let __v_33: G = (__v_30 + __v_32);
+    let __v_34: G = (__v_28 + __v_33);
+    let __v_35: G = (__v_26 + __v_34);
+    let __v_36: G = (__v_24 + __v_35);
+    let __v_37: G = (__v_22 + __v_36);
+    let __v_38: G = (__v_20 + __v_37);
+    let __v_39: G = (__v_1 + __v_38);
+    let __v_40: G = G::from_u64(256);
+    let __v_41: G = (__v_40 * __v_11);
+    let __v_42: G = G::from_u64(65536);
+    let __v_43: G = (__v_42 * __v_12);
+    let __v_44: G = G::from_u64(16777216);
+    let __v_45: G = (__v_44 * __v_13);
+    let __v_46: G = G::from_u64(4294967296);
+    let __v_47: G = (__v_46 * __v_14);
+    let __v_48: G = G::from_u64(1099511627776);
+    let __v_49: G = (__v_48 * __v_15);
+    let __v_50: G = G::from_u64(281474976710656);
+    let __v_51: G = (__v_50 * __v_16);
+    let __v_52: G = G::from_u64(72057594037927936);
+    let __v_53: G = (__v_52 * __v_17);
+    let __v_54: G = (__v_51 + __v_53);
+    let __v_55: G = (__v_49 + __v_54);
+    let __v_56: G = (__v_47 + __v_55);
+    let __v_57: G = (__v_45 + __v_56);
+    let __v_58: G = (__v_43 + __v_57);
+    let __v_59: G = (__v_41 + __v_58);
+    let __v_60: G = (__v_10 + __v_59);
+    let __ret: [G; OUT_56] = [__v_39, __v_60, __v_18];
+    if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_57: usize = 1;
+const IN_57: usize = 1;
+const OUT_57: usize = 2;
+fn aiur_fn_57(
+  inp: [G; IN_57],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_57], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_57] = [__v_3, __v_4];
     if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_58: usize = 1;
-const IN_58: usize = 1;
-const OUT_58: usize = 3;
+const INPUT_SIZE_58: usize = 2;
+const IN_58: usize = 2;
+const OUT_58: usize = 2;
 fn aiur_fn_58(
   inp: [G; IN_58],
   record: &mut QueryRecord,
@@ -2311,23 +2713,28 @@ fn aiur_fn_58(
 ) -> Result<[G; OUT_58], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
+    let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_58] = [__v_3, __v_4, __v_2];
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_58] = [__v_4, __v_0];
         if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __v_4: G = __r_arr[1];
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_58] = [__v_5, __v_3, __v_4];
+        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_58] = [__v_9, __v_7];
         if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
@@ -2337,7 +2744,7 @@ fn aiur_fn_58(
 
 const INPUT_SIZE_59: usize = 1;
 const IN_59: usize = 1;
-const OUT_59: usize = 24;
+const OUT_59: usize = 2;
 fn aiur_fn_59(
   inp: [G; IN_59],
   record: &mut QueryRecord,
@@ -2346,80 +2753,21 @@ fn aiur_fn_59(
 ) -> Result<[G; OUT_59], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } } else { aiur_fn_60(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_14, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __v_18: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_18, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __v_20: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_23: G = __r_arr[0];
-    let __v_24: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_24, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __v_26: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
-    let __v_27: G = __r_arr[0];
-    let __v_28: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
-    let __v_29: G = __r_arr[0];
-    let __v_30: G = __r_arr[1];
-    let __v_31: G = __r_arr[2];
-    let __v_32: G = __r_arr[3];
-    let __v_33: G = __r_arr[4];
-    let __v_34: G = __r_arr[5];
-    let __v_35: G = __r_arr[6];
-    let __v_36: G = __r_arr[7];
-    let __v_37: G = __r_arr[8];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_38: G = __r_arr[0];
-    let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
-    let __v_40: G = __r_arr[0];
-    let __v_41: G = __r_arr[1];
-    let __v_42: G = __r_arr[2];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_43: G = __r_arr[0];
-    let __v_44: G = __r_arr[1];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_45: G = __r_arr[0];
-    let __v_46: G = __r_arr[1];
-    let __ret: [G; OUT_59] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_40, __v_41, __v_43, __v_45, __v_46];
+    let __ret: [G; OUT_59] = [__v_3, __v_4];
     if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_60: usize = 4;
-const IN_60: usize = 4;
-const OUT_60: usize = 1;
+const INPUT_SIZE_60: usize = 2;
+const IN_60: usize = 2;
+const OUT_60: usize = 2;
 fn aiur_fn_60(
   inp: [G; IN_60],
   record: &mut QueryRecord,
@@ -2429,26 +2777,44 @@ fn aiur_fn_60(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = G::from_u64(256);
-    let __v_5: G = (__v_4 * __v_1);
-    let __v_6: G = G::from_u64(65536);
-    let __v_7: G = (__v_6 * __v_2);
-    let __v_8: G = G::from_u64(16777216);
-    let __v_9: G = (__v_8 * __v_3);
-    let __v_10: G = (__v_7 + __v_9);
-    let __v_11: G = (__v_5 + __v_10);
-    let __v_12: G = (__v_0 + __v_11);
-    let __ret: [G; OUT_60] = [__v_12];
-    if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_60] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } } else { aiur_fn_60(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_60] = [__v_16, __v_14];
+        if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_61: usize = 32;
-const IN_61: usize = 32;
-const OUT_61: usize = 8;
+const INPUT_SIZE_61: usize = 1;
+const IN_61: usize = 1;
+const OUT_61: usize = 2;
 fn aiur_fn_61(
   inp: [G; IN_61],
   record: &mut QueryRecord,
@@ -2457,11387 +2823,4084 @@ fn aiur_fn_61(
 ) -> Result<[G; OUT_61], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = G::from_u64(256);
-    let __v_33: G = (__v_32 * __v_1);
-    let __v_34: G = G::from_u64(65536);
-    let __v_35: G = (__v_34 * __v_2);
-    let __v_36: G = G::from_u64(16777216);
-    let __v_37: G = (__v_36 * __v_3);
-    let __v_38: G = (__v_35 + __v_37);
-    let __v_39: G = (__v_33 + __v_38);
-    let __v_40: G = (__v_0 + __v_39);
-    let __v_41: G = G::from_u64(256);
-    let __v_42: G = (__v_41 * __v_5);
-    let __v_43: G = G::from_u64(65536);
-    let __v_44: G = (__v_43 * __v_6);
-    let __v_45: G = G::from_u64(16777216);
-    let __v_46: G = (__v_45 * __v_7);
-    let __v_47: G = (__v_44 + __v_46);
-    let __v_48: G = (__v_42 + __v_47);
-    let __v_49: G = (__v_4 + __v_48);
-    let __v_50: G = G::from_u64(256);
-    let __v_51: G = (__v_50 * __v_9);
-    let __v_52: G = G::from_u64(65536);
-    let __v_53: G = (__v_52 * __v_10);
-    let __v_54: G = G::from_u64(16777216);
-    let __v_55: G = (__v_54 * __v_11);
-    let __v_56: G = (__v_53 + __v_55);
-    let __v_57: G = (__v_51 + __v_56);
-    let __v_58: G = (__v_8 + __v_57);
-    let __v_59: G = G::from_u64(256);
-    let __v_60: G = (__v_59 * __v_13);
-    let __v_61: G = G::from_u64(65536);
-    let __v_62: G = (__v_61 * __v_14);
-    let __v_63: G = G::from_u64(16777216);
-    let __v_64: G = (__v_63 * __v_15);
-    let __v_65: G = (__v_62 + __v_64);
-    let __v_66: G = (__v_60 + __v_65);
-    let __v_67: G = (__v_12 + __v_66);
-    let __v_68: G = G::from_u64(256);
-    let __v_69: G = (__v_68 * __v_17);
-    let __v_70: G = G::from_u64(65536);
-    let __v_71: G = (__v_70 * __v_18);
-    let __v_72: G = G::from_u64(16777216);
-    let __v_73: G = (__v_72 * __v_19);
-    let __v_74: G = (__v_71 + __v_73);
-    let __v_75: G = (__v_69 + __v_74);
-    let __v_76: G = (__v_16 + __v_75);
-    let __v_77: G = G::from_u64(256);
-    let __v_78: G = (__v_77 * __v_21);
-    let __v_79: G = G::from_u64(65536);
-    let __v_80: G = (__v_79 * __v_22);
-    let __v_81: G = G::from_u64(16777216);
-    let __v_82: G = (__v_81 * __v_23);
-    let __v_83: G = (__v_80 + __v_82);
-    let __v_84: G = (__v_78 + __v_83);
-    let __v_85: G = (__v_20 + __v_84);
-    let __v_86: G = G::from_u64(256);
-    let __v_87: G = (__v_86 * __v_25);
-    let __v_88: G = G::from_u64(65536);
-    let __v_89: G = (__v_88 * __v_26);
-    let __v_90: G = G::from_u64(16777216);
-    let __v_91: G = (__v_90 * __v_27);
-    let __v_92: G = (__v_89 + __v_91);
-    let __v_93: G = (__v_87 + __v_92);
-    let __v_94: G = (__v_24 + __v_93);
-    let __v_95: G = G::from_u64(256);
-    let __v_96: G = (__v_95 * __v_29);
-    let __v_97: G = G::from_u64(65536);
-    let __v_98: G = (__v_97 * __v_30);
-    let __v_99: G = G::from_u64(16777216);
-    let __v_100: G = (__v_99 * __v_31);
-    let __v_101: G = (__v_98 + __v_100);
-    let __v_102: G = (__v_96 + __v_101);
-    let __v_103: G = (__v_28 + __v_102);
-    let __ret: [G; OUT_61] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_61] = [__v_3, __v_4];
     if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_62: usize = 1;
-const IN_62: usize = 1;
-const OUT_62: usize = 32;
+const INPUT_SIZE_62: usize = 2;
+const IN_62: usize = 2;
+const OUT_62: usize = 2;
 fn aiur_fn_62(
   inp: [G; IN_62],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_62], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(103);
-    let __v_2: G = G::from_u64(230);
-    let __v_3: G = G::from_u64(9);
-    let __v_4: G = G::from_u64(106);
-    let __v_5: G = G::from_u64(133);
-    let __v_6: G = G::from_u64(174);
-    let __v_7: G = G::from_u64(103);
-    let __v_8: G = G::from_u64(187);
-    let __v_9: G = G::from_u64(114);
-    let __v_10: G = G::from_u64(243);
-    let __v_11: G = G::from_u64(110);
-    let __v_12: G = G::from_u64(60);
-    let __v_13: G = G::from_u64(58);
-    let __v_14: G = G::from_u64(245);
-    let __v_15: G = G::from_u64(79);
-    let __v_16: G = G::from_u64(165);
-    let __v_17: G = G::from_u64(127);
-    let __v_18: G = G::from_u64(82);
-    let __v_19: G = G::from_u64(14);
-    let __v_20: G = G::from_u64(81);
-    let __v_21: G = G::from_u64(140);
-    let __v_22: G = G::from_u64(104);
-    let __v_23: G = G::from_u64(5);
-    let __v_24: G = G::from_u64(155);
-    let __v_25: G = G::from_u64(171);
-    let __v_26: G = G::from_u64(217);
-    let __v_27: G = G::from_u64(131);
-    let __v_28: G = G::from_u64(31);
-    let __v_29: G = G::from_u64(25);
-    let __v_30: G = G::from_u64(205);
-    let __v_31: G = G::from_u64(224);
-    let __v_32: G = G::from_u64(91);
-    let __v_33: G = G::from_u64(1);
-    let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = G::from_u64(0);
-    let __v_38: G = G::from_u64(0);
-    let __v_39: G = G::from_u64(0);
-    let __v_40: G = G::from_u64(0);
-    let __v_41: G = G::from_u64(0);
-    let __v_42: G = G::from_u64(0);
-    let __v_43: G = G::from_u64(0);
-    let __v_44: G = G::from_u64(0);
-    let __v_45: G = G::from_u64(0);
-    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_48: G = G::from_u64(1);
-    let __v_49: G = G::from_u64(1);
-    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
-    let __v_52: G = __r_arr[0];
-    let __v_53: G = __r_arr[1];
-    let __v_54: G = __r_arr[2];
-    let __v_55: G = __r_arr[3];
-    let __v_56: G = __r_arr[4];
-    let __v_57: G = __r_arr[5];
-    let __v_58: G = __r_arr[6];
-    let __v_59: G = __r_arr[7];
-    let __v_60: G = __r_arr[8];
-    let __v_61: G = __r_arr[9];
-    let __v_62: G = __r_arr[10];
-    let __v_63: G = __r_arr[11];
-    let __v_64: G = __r_arr[12];
-    let __v_65: G = __r_arr[13];
-    let __v_66: G = __r_arr[14];
-    let __v_67: G = __r_arr[15];
-    let __v_68: G = __r_arr[16];
-    let __v_69: G = __r_arr[17];
-    let __v_70: G = __r_arr[18];
-    let __v_71: G = __r_arr[19];
-    let __v_72: G = __r_arr[20];
-    let __v_73: G = __r_arr[21];
-    let __v_74: G = __r_arr[22];
-    let __v_75: G = __r_arr[23];
-    let __v_76: G = __r_arr[24];
-    let __v_77: G = __r_arr[25];
-    let __v_78: G = __r_arr[26];
-    let __v_79: G = __r_arr[27];
-    let __v_80: G = __r_arr[28];
-    let __v_81: G = __r_arr[29];
-    let __v_82: G = __r_arr[30];
-    let __v_83: G = __r_arr[31];
-    let __ret: [G; OUT_62] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83];
-    if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_63: usize = 34;
-const IN_63: usize = 34;
-const OUT_63: usize = 34;
-fn aiur_fn_63(
-  inp: [G; IN_63],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_63], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-    let __v_34: G = __loaded[0];
-    let __v_35: G = __loaded[1];
-    let __v_36: G = __loaded[2];
-    let __v_37: G = __loaded[3];
-    let __v_38: G = __loaded[4];
-    let __v_39: G = __loaded[5];
-    let __v_40: G = __loaded[6];
-    let __v_41: G = __loaded[7];
-    let __v_42: G = __loaded[8];
-    let __v_43: G = __loaded[9];
-    let __v_44: G = __loaded[10];
-    let __v_45: G = __loaded[11];
-    let __v_46: G = __loaded[12];
-    let __v_47: G = __loaded[13];
-    let __v_48: G = __loaded[14];
-    let __v_49: G = __loaded[15];
-    let __v_50: G = __loaded[16];
-    let __v_51: G = __loaded[17];
-    let __v_52: G = __loaded[18];
-    let __v_53: G = __loaded[19];
-    let __v_54: G = __loaded[20];
-    let __v_55: G = __loaded[21];
-    let __v_56: G = __loaded[22];
-    let __v_57: G = __loaded[23];
-    let __v_58: G = __loaded[24];
-    let __v_59: G = __loaded[25];
-    let __v_60: G = __loaded[26];
-    let __v_61: G = __loaded[27];
-    let __v_62: G = __loaded[28];
-    let __v_63: G = __loaded[29];
-    let __v_64: G = __loaded[30];
-    let __v_65: G = __loaded[31];
-    let __v_66: G = __loaded[32];
-    let __v_67: G = __loaded[33];
-    match __v_34.as_canonical_u64() {
-      1u64 => {
-        let __v_68: G = G::from_u64(1);
-        let __ret: [G; OUT_63] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
-        if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_62] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = __r_arr[2];
+        let __v_14: G = __r_arr[3];
+        let __v_15: G = __r_arr[4];
+        let __v_16: G = __r_arr[5];
+        let __v_17: G = __r_arr[6];
+        let __v_18: G = __r_arr[7];
+        let __v_19: G = __r_arr[8];
+        let __v_20: G = G::from_u64(256);
+        let __v_21: G = (__v_20 * __v_3);
+        let __v_22: G = G::from_u64(65536);
+        let __v_23: G = (__v_22 * __v_4);
+        let __v_24: G = G::from_u64(16777216);
+        let __v_25: G = (__v_24 * __v_5);
+        let __v_26: G = G::from_u64(4294967296);
+        let __v_27: G = (__v_26 * __v_6);
+        let __v_28: G = G::from_u64(1099511627776);
+        let __v_29: G = (__v_28 * __v_7);
+        let __v_30: G = G::from_u64(281474976710656);
+        let __v_31: G = (__v_30 * __v_8);
+        let __v_32: G = G::from_u64(72057594037927936);
+        let __v_33: G = (__v_32 * __v_9);
+        let __v_34: G = (__v_31 + __v_33);
+        let __v_35: G = (__v_29 + __v_34);
+        let __v_36: G = (__v_27 + __v_35);
+        let __v_37: G = (__v_25 + __v_36);
+        let __v_38: G = (__v_23 + __v_37);
+        let __v_39: G = (__v_21 + __v_38);
+        let __v_40: G = (__v_2 + __v_39);
+        let __v_41: G = G::from_u64(256);
+        let __v_42: G = (__v_41 * __v_12);
+        let __v_43: G = G::from_u64(65536);
+        let __v_44: G = (__v_43 * __v_13);
+        let __v_45: G = G::from_u64(16777216);
+        let __v_46: G = (__v_45 * __v_14);
+        let __v_47: G = G::from_u64(4294967296);
+        let __v_48: G = (__v_47 * __v_15);
+        let __v_49: G = G::from_u64(1099511627776);
+        let __v_50: G = (__v_49 * __v_16);
+        let __v_51: G = G::from_u64(281474976710656);
+        let __v_52: G = (__v_51 * __v_17);
+        let __v_53: G = G::from_u64(72057594037927936);
+        let __v_54: G = (__v_53 * __v_18);
+        let __v_55: G = (__v_52 + __v_54);
+        let __v_56: G = (__v_50 + __v_55);
+        let __v_57: G = (__v_48 + __v_56);
+        let __v_58: G = (__v_46 + __v_57);
+        let __v_59: G = (__v_44 + __v_58);
+        let __v_60: G = (__v_42 + __v_59);
+        let __v_61: G = (__v_11 + __v_60);
+        let __v_62: G = G::from_u64(1);
+        let __v_63: G = (__v_1 - __v_62);
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_19, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } };
+        let __v_64: G = __r_arr[0];
+        let __v_65: G = __r_arr[1];
+        let __v_66: G = G::from_u64(0);
+        let __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_62] = [__v_67, __v_65];
+        if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
+    }
+  })
+}
+
+const INPUT_SIZE_63: usize = 1;
+const IN_63: usize = 1;
+const OUT_63: usize = 2;
+fn aiur_fn_63(
+  inp: [G; IN_63],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_63], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_63] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_64: usize = 2;
+const IN_64: usize = 2;
+const OUT_64: usize = 2;
+fn aiur_fn_64(
+  inp: [G; IN_64],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_64], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_68: G = G::from_u64(0);
-        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } };
-        let __v_69: G = __r_arr[0];
-        let __v_70: G = __r_arr[1];
-        let __v_71: G = __r_arr[2];
-        let __v_72: G = __r_arr[3];
-        let __v_73: G = __r_arr[4];
-        let __v_74: G = __r_arr[5];
-        let __v_75: G = __r_arr[6];
-        let __v_76: G = __r_arr[7];
-        let __v_77: G = __r_arr[8];
-        let __v_78: G = __r_arr[9];
-        let __v_79: G = __r_arr[10];
-        let __v_80: G = __r_arr[11];
-        let __v_81: G = __r_arr[12];
-        let __v_82: G = __r_arr[13];
-        let __v_83: G = __r_arr[14];
-        let __v_84: G = __r_arr[15];
-        let __v_85: G = __r_arr[16];
-        let __v_86: G = __r_arr[17];
-        let __v_87: G = __r_arr[18];
-        let __v_88: G = __r_arr[19];
-        let __v_89: G = __r_arr[20];
-        let __v_90: G = __r_arr[21];
-        let __v_91: G = __r_arr[22];
-        let __v_92: G = __r_arr[23];
-        let __v_93: G = __r_arr[24];
-        let __v_94: G = __r_arr[25];
-        let __v_95: G = __r_arr[26];
-        let __v_96: G = __r_arr[27];
-        let __v_97: G = __r_arr[28];
-        let __v_98: G = __r_arr[29];
-        let __v_99: G = __r_arr[30];
-        let __v_100: G = __r_arr[31];
-        let __v_101: G = __r_arr[32];
-        let __v_102: G = __r_arr[33];
-        match __v_69.as_canonical_u64() {
-          0u64 => {
-            let __v_103: G = G::from_u64(1);
-            let __ret: [G; OUT_63] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
-            if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_103: G = G::from_u64(4);
-            let __v_104: G = G::from_u64(8);
-            let __v_105: G = G::from_u64(103);
-            let __v_106: G = G::from_u64(230);
-            let __v_107: G = G::from_u64(9);
-            let __v_108: G = G::from_u64(106);
-            let __v_109: G = G::from_u64(133);
-            let __v_110: G = G::from_u64(174);
-            let __v_111: G = G::from_u64(103);
-            let __v_112: G = G::from_u64(187);
-            let __v_113: G = G::from_u64(114);
-            let __v_114: G = G::from_u64(243);
-            let __v_115: G = G::from_u64(110);
-            let __v_116: G = G::from_u64(60);
-            let __v_117: G = G::from_u64(58);
-            let __v_118: G = G::from_u64(245);
-            let __v_119: G = G::from_u64(79);
-            let __v_120: G = G::from_u64(165);
-            let __v_121: G = G::from_u64(127);
-            let __v_122: G = G::from_u64(82);
-            let __v_123: G = G::from_u64(14);
-            let __v_124: G = G::from_u64(81);
-            let __v_125: G = G::from_u64(140);
-            let __v_126: G = G::from_u64(104);
-            let __v_127: G = G::from_u64(5);
-            let __v_128: G = G::from_u64(155);
-            let __v_129: G = G::from_u64(171);
-            let __v_130: G = G::from_u64(217);
-            let __v_131: G = G::from_u64(131);
-            let __v_132: G = G::from_u64(31);
-            let __v_133: G = G::from_u64(25);
-            let __v_134: G = G::from_u64(205);
-            let __v_135: G = G::from_u64(224);
-            let __v_136: G = G::from_u64(91);
-            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-            let __v_137: G = __loaded[0];
-            let __v_138: G = __loaded[1];
-            let __v_139: G = __loaded[2];
-            let __v_140: G = __loaded[3];
-            let __v_141: G = __loaded[4];
-            let __v_142: G = __loaded[5];
-            let __v_143: G = __loaded[6];
-            let __v_144: G = __loaded[7];
-            let __v_145: G = __loaded[8];
-            let __v_146: G = __loaded[9];
-            let __v_147: G = __loaded[10];
-            let __v_148: G = __loaded[11];
-            let __v_149: G = __loaded[12];
-            let __v_150: G = __loaded[13];
-            let __v_151: G = __loaded[14];
-            let __v_152: G = __loaded[15];
-            let __v_153: G = __loaded[16];
-            let __v_154: G = __loaded[17];
-            let __v_155: G = __loaded[18];
-            let __v_156: G = __loaded[19];
-            let __v_157: G = __loaded[20];
-            let __v_158: G = __loaded[21];
-            let __v_159: G = __loaded[22];
-            let __v_160: G = __loaded[23];
-            let __v_161: G = __loaded[24];
-            let __v_162: G = __loaded[25];
-            let __v_163: G = __loaded[26];
-            let __v_164: G = __loaded[27];
-            let __v_165: G = __loaded[28];
-            let __v_166: G = __loaded[29];
-            let __v_167: G = __loaded[30];
-            let __v_168: G = __loaded[31];
-            let __v_169: G = __loaded[32];
-            let __v_170: G = __loaded[33];
-            match __v_137.as_canonical_u64() {
-              1u64 => {
-                let __v_171: G = (__v_104 * __v_33);
-                let __v_172: G = (__v_103 + __v_171);
-                let __v_173: G = G::from_u64(0);
-                let __v_174: G = G::from_u64(0);
-                let __v_175: G = G::from_u64(0);
-                let __v_176: G = G::from_u64(0);
-                let __v_177: G = G::from_u64(0);
-                let __v_178: G = G::from_u64(0);
-                let __v_179: G = G::from_u64(0);
-                let __v_180: G = G::from_u64(0);
-                let __v_181: G = G::from_u64(64);
-                let __v_182: G = G::from_u64(103);
-                let __v_183: G = G::from_u64(230);
-                let __v_184: G = G::from_u64(9);
-                let __v_185: G = G::from_u64(106);
-                let __v_186: G = G::from_u64(133);
-                let __v_187: G = G::from_u64(174);
-                let __v_188: G = G::from_u64(103);
-                let __v_189: G = G::from_u64(187);
-                let __v_190: G = G::from_u64(114);
-                let __v_191: G = G::from_u64(243);
-                let __v_192: G = G::from_u64(110);
-                let __v_193: G = G::from_u64(60);
-                let __v_194: G = G::from_u64(58);
-                let __v_195: G = G::from_u64(245);
-                let __v_196: G = G::from_u64(79);
-                let __v_197: G = G::from_u64(165);
-                let __v_198: G = G::from_u64(0);
-                let __v_199: G = G::from_u64(0);
-                let __v_200: G = G::from_u64(0);
-                let __v_201: G = G::from_u64(0);
-                let __v_202: G = G::from_u64(0);
-                let __v_203: G = G::from_u64(0);
-                let __v_204: G = G::from_u64(0);
-                let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-                let __v_205: G = __r_arr[0];
-                let __v_206: G = __r_arr[1];
-                let __v_207: G = __r_arr[2];
-                let __v_208: G = __r_arr[3];
-                let __v_209: G = __r_arr[4];
-                let __v_210: G = __r_arr[5];
-                let __v_211: G = __r_arr[6];
-                let __v_212: G = __r_arr[7];
-                let __v_213: G = __r_arr[8];
-                let __v_214: G = __r_arr[9];
-                let __v_215: G = __r_arr[10];
-                let __v_216: G = __r_arr[11];
-                let __v_217: G = __r_arr[12];
-                let __v_218: G = __r_arr[13];
-                let __v_219: G = __r_arr[14];
-                let __v_220: G = __r_arr[15];
-                let __v_221: G = __r_arr[16];
-                let __v_222: G = __r_arr[17];
-                let __v_223: G = __r_arr[18];
-                let __v_224: G = __r_arr[19];
-                let __v_225: G = __r_arr[20];
-                let __v_226: G = __r_arr[21];
-                let __v_227: G = __r_arr[22];
-                let __v_228: G = __r_arr[23];
-                let __v_229: G = __r_arr[24];
-                let __v_230: G = __r_arr[25];
-                let __v_231: G = __r_arr[26];
-                let __v_232: G = __r_arr[27];
-                let __v_233: G = __r_arr[28];
-                let __v_234: G = __r_arr[29];
-                let __v_235: G = __r_arr[30];
-                let __v_236: G = __r_arr[31];
-                let __v_237: G = G::from_u64(0);
-                let __v_238: G = G::from_u64(0);
-                let __v_239: G = G::from_u64(0);
-                let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_63] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
-                if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_171: G = G::from_u64(0);
-                let __v_172: G = G::from_u64(0);
-                let __v_173: G = G::from_u64(0);
-                let __v_174: G = G::from_u64(0);
-                let __v_175: G = G::from_u64(0);
-                let __v_176: G = G::from_u64(0);
-                let __v_177: G = G::from_u64(0);
-                let __v_178: G = G::from_u64(0);
-                let __v_179: G = G::from_u64(64);
-                let __v_180: G = G::from_u64(103);
-                let __v_181: G = G::from_u64(230);
-                let __v_182: G = G::from_u64(9);
-                let __v_183: G = G::from_u64(106);
-                let __v_184: G = G::from_u64(133);
-                let __v_185: G = G::from_u64(174);
-                let __v_186: G = G::from_u64(103);
-                let __v_187: G = G::from_u64(187);
-                let __v_188: G = G::from_u64(114);
-                let __v_189: G = G::from_u64(243);
-                let __v_190: G = G::from_u64(110);
-                let __v_191: G = G::from_u64(60);
-                let __v_192: G = G::from_u64(58);
-                let __v_193: G = G::from_u64(245);
-                let __v_194: G = G::from_u64(79);
-                let __v_195: G = G::from_u64(165);
-                let __v_196: G = G::from_u64(0);
-                let __v_197: G = G::from_u64(0);
-                let __v_198: G = G::from_u64(0);
-                let __v_199: G = G::from_u64(0);
-                let __v_200: G = G::from_u64(0);
-                let __v_201: G = G::from_u64(0);
-                let __v_202: G = G::from_u64(0);
-                let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-                let __v_203: G = __r_arr[0];
-                let __v_204: G = __r_arr[1];
-                let __v_205: G = __r_arr[2];
-                let __v_206: G = __r_arr[3];
-                let __v_207: G = __r_arr[4];
-                let __v_208: G = __r_arr[5];
-                let __v_209: G = __r_arr[6];
-                let __v_210: G = __r_arr[7];
-                let __v_211: G = __r_arr[8];
-                let __v_212: G = __r_arr[9];
-                let __v_213: G = __r_arr[10];
-                let __v_214: G = __r_arr[11];
-                let __v_215: G = __r_arr[12];
-                let __v_216: G = __r_arr[13];
-                let __v_217: G = __r_arr[14];
-                let __v_218: G = __r_arr[15];
-                let __v_219: G = __r_arr[16];
-                let __v_220: G = __r_arr[17];
-                let __v_221: G = __r_arr[18];
-                let __v_222: G = __r_arr[19];
-                let __v_223: G = __r_arr[20];
-                let __v_224: G = __r_arr[21];
-                let __v_225: G = __r_arr[22];
-                let __v_226: G = __r_arr[23];
-                let __v_227: G = __r_arr[24];
-                let __v_228: G = __r_arr[25];
-                let __v_229: G = __r_arr[26];
-                let __v_230: G = __r_arr[27];
-                let __v_231: G = __r_arr[28];
-                let __v_232: G = __r_arr[29];
-                let __v_233: G = __r_arr[30];
-                let __v_234: G = __r_arr[31];
-                let __v_235: G = G::from_u64(0);
-                let __v_236: G = G::from_u64(0);
-                let __v_237: G = G::from_u64(0);
-                let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_63] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
-                if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64()));
-          },
-        }
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_64] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_64] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_64: usize = 1;
-const IN_64: usize = 1;
-const OUT_64: usize = 32;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+const INPUT_SIZE_65: usize = 1;
+const IN_65: usize = 1;
+const OUT_65: usize = 2;
+fn aiur_fn_65(
+  inp: [G; IN_65],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_64], ExecError> {
+) -> Result<[G; OUT_65], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    let __v_11: G = __loaded[10];
-    let __v_12: G = __loaded[11];
-    let __v_13: G = __loaded[12];
-    let __v_14: G = __loaded[13];
-    let __v_15: G = __loaded[14];
-    let __v_16: G = __loaded[15];
-    let __v_17: G = __loaded[16];
-    let __v_18: G = __loaded[17];
-    let __v_19: G = __loaded[18];
-    let __v_20: G = __loaded[19];
-    let __v_21: G = __loaded[20];
-    let __v_22: G = __loaded[21];
-    let __v_23: G = __loaded[22];
-    let __v_24: G = __loaded[23];
-    let __v_25: G = __loaded[24];
-    let __v_26: G = __loaded[25];
-    let __v_27: G = __loaded[26];
-    let __v_28: G = __loaded[27];
-    let __v_29: G = __loaded[28];
-    let __v_30: G = __loaded[29];
-    let __v_31: G = __loaded[30];
-    let __v_32: G = __loaded[31];
-    let __v_33: G = __loaded[32];
-    let __v_34: G = __loaded[33];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_65] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_66: usize = 2;
+const IN_66: usize = 2;
+const OUT_66: usize = 2;
+fn aiur_fn_66(
+  inp: [G; IN_66],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_66], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-        let __v_35: G = __loaded[0];
-        let __v_36: G = __loaded[1];
-        let __v_37: G = __loaded[2];
-        let __v_38: G = __loaded[3];
-        let __v_39: G = __loaded[4];
-        let __v_40: G = __loaded[5];
-        let __v_41: G = __loaded[6];
-        let __v_42: G = __loaded[7];
-        let __v_43: G = __loaded[8];
-        let __v_44: G = __loaded[9];
-        let __v_45: G = __loaded[10];
-        let __v_46: G = __loaded[11];
-        let __v_47: G = __loaded[12];
-        let __v_48: G = __loaded[13];
-        let __v_49: G = __loaded[14];
-        let __v_50: G = __loaded[15];
-        let __v_51: G = __loaded[16];
-        let __v_52: G = __loaded[17];
-        let __v_53: G = __loaded[18];
-        let __v_54: G = __loaded[19];
-        let __v_55: G = __loaded[20];
-        let __v_56: G = __loaded[21];
-        let __v_57: G = __loaded[22];
-        let __v_58: G = __loaded[23];
-        let __v_59: G = __loaded[24];
-        let __v_60: G = __loaded[25];
-        let __v_61: G = __loaded[26];
-        let __v_62: G = __loaded[27];
-        let __v_63: G = __loaded[28];
-        let __v_64: G = __loaded[29];
-        let __v_65: G = __loaded[30];
-        let __v_66: G = __loaded[31];
-        let __v_67: G = __loaded[32];
-        let __v_68: G = __loaded[33];
-        match __v_35.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_64] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34];
-            if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_69: G = G::from_u64(1);
-            let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } };
-            let __v_70: G = __r_arr[0];
-            let __v_71: G = __r_arr[1];
-            let __v_72: G = __r_arr[2];
-            let __v_73: G = __r_arr[3];
-            let __v_74: G = __r_arr[4];
-            let __v_75: G = __r_arr[5];
-            let __v_76: G = __r_arr[6];
-            let __v_77: G = __r_arr[7];
-            let __v_78: G = __r_arr[8];
-            let __v_79: G = __r_arr[9];
-            let __v_80: G = __r_arr[10];
-            let __v_81: G = __r_arr[11];
-            let __v_82: G = __r_arr[12];
-            let __v_83: G = __r_arr[13];
-            let __v_84: G = __r_arr[14];
-            let __v_85: G = __r_arr[15];
-            let __v_86: G = __r_arr[16];
-            let __v_87: G = __r_arr[17];
-            let __v_88: G = __r_arr[18];
-            let __v_89: G = __r_arr[19];
-            let __v_90: G = __r_arr[20];
-            let __v_91: G = __r_arr[21];
-            let __v_92: G = __r_arr[22];
-            let __v_93: G = __r_arr[23];
-            let __v_94: G = __r_arr[24];
-            let __v_95: G = __r_arr[25];
-            let __v_96: G = __r_arr[26];
-            let __v_97: G = __r_arr[27];
-            let __v_98: G = __r_arr[28];
-            let __v_99: G = __r_arr[29];
-            let __v_100: G = __r_arr[30];
-            let __v_101: G = __r_arr[31];
-            let __v_102: G = __r_arr[32];
-            let __v_103: G = __r_arr[33];
-            match __v_70.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
-                let __v_104: G = __r_arr[0];
-                let __v_105: G = __r_arr[1];
-                let __v_106: G = __r_arr[2];
-                let __v_107: G = __r_arr[3];
-                let __v_108: G = __r_arr[4];
-                let __v_109: G = __r_arr[5];
-                let __v_110: G = __r_arr[6];
-                let __v_111: G = __r_arr[7];
-                let __v_112: G = __r_arr[8];
-                let __v_113: G = __r_arr[9];
-                let __v_114: G = __r_arr[10];
-                let __v_115: G = __r_arr[11];
-                let __v_116: G = __r_arr[12];
-                let __v_117: G = __r_arr[13];
-                let __v_118: G = __r_arr[14];
-                let __v_119: G = __r_arr[15];
-                let __v_120: G = __r_arr[16];
-                let __v_121: G = __r_arr[17];
-                let __v_122: G = __r_arr[18];
-                let __v_123: G = __r_arr[19];
-                let __v_124: G = __r_arr[20];
-                let __v_125: G = __r_arr[21];
-                let __v_126: G = __r_arr[22];
-                let __v_127: G = __r_arr[23];
-                let __v_128: G = __r_arr[24];
-                let __v_129: G = __r_arr[25];
-                let __v_130: G = __r_arr[26];
-                let __v_131: G = __r_arr[27];
-                let __v_132: G = __r_arr[28];
-                let __v_133: G = __r_arr[29];
-                let __v_134: G = __r_arr[30];
-                let __v_135: G = __r_arr[31];
-                let __ret: [G; OUT_64] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135];
-                if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __v_104: G = G::from_u64(0);
-                let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
-                let __v_106: G = __r_arr[0];
-                let __v_107: G = __r_arr[1];
-                let __v_108: G = __r_arr[2];
-                let __v_109: G = __r_arr[3];
-                let __v_110: G = __r_arr[4];
-                let __v_111: G = __r_arr[5];
-                let __v_112: G = __r_arr[6];
-                let __v_113: G = __r_arr[7];
-                let __v_114: G = __r_arr[8];
-                let __v_115: G = __r_arr[9];
-                let __v_116: G = __r_arr[10];
-                let __v_117: G = __r_arr[11];
-                let __v_118: G = __r_arr[12];
-                let __v_119: G = __r_arr[13];
-                let __v_120: G = __r_arr[14];
-                let __v_121: G = __r_arr[15];
-                let __v_122: G = __r_arr[16];
-                let __v_123: G = __r_arr[17];
-                let __v_124: G = __r_arr[18];
-                let __v_125: G = __r_arr[19];
-                let __v_126: G = __r_arr[20];
-                let __v_127: G = __r_arr[21];
-                let __v_128: G = __r_arr[22];
-                let __v_129: G = __r_arr[23];
-                let __v_130: G = __r_arr[24];
-                let __v_131: G = __r_arr[25];
-                let __v_132: G = __r_arr[26];
-                let __v_133: G = __r_arr[27];
-                let __v_134: G = __r_arr[28];
-                let __v_135: G = __r_arr[29];
-                let __v_136: G = __r_arr[30];
-                let __v_137: G = __r_arr[31];
-                let __ret: [G; OUT_64] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
-                if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
-              },
-            }
-          },
-        }
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_66] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_66] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_65: usize = 7;
-const IN_65: usize = 7;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_67: usize = 1;
+const IN_67: usize = 1;
+const OUT_67: usize = 4;
+fn aiur_fn_67(
+  inp: [G; IN_67],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_65], ExecError> {
+) -> Result<[G; OUT_67], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_10];
-        if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_67] = [__v_1, __v_3, __v_5, __v_6];
+    if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_68: usize = 1;
+const IN_68: usize = 1;
+const OUT_68: usize = 3;
+fn aiur_fn_68(
+  inp: [G; IN_68],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_68], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        match __v_2.as_canonical_u64() {
-          63u64 => {
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_12];
-            if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_2 + __v_12);
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_16];
-            if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_68] = [__v_3, __v_4, __v_2];
+        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_68] = [__v_5, __v_3, __v_4];
+        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_66: usize = 1;
-const IN_66: usize = 1;
-const OUT_66: usize = 64;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+const INPUT_SIZE_69: usize = 1;
+const IN_69: usize = 1;
+const OUT_69: usize = 24;
+fn aiur_fn_69(
+  inp: [G; IN_69],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_66], ExecError> {
+) -> Result<[G; OUT_69], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_7: G = __loaded[0];
-            let __v_8: G = __loaded[1];
-            let __v_9: G = __loaded[2];
-            match __v_7.as_canonical_u64() {
-              0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                let __v_12: G = __loaded[2];
-                match __v_10.as_canonical_u64() {
-                  0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_13: G = __loaded[0];
-                    let __v_14: G = __loaded[1];
-                    let __v_15: G = __loaded[2];
-                    match __v_13.as_canonical_u64() {
-                      0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_16: G = __loaded[0];
-                        let __v_17: G = __loaded[1];
-                        let __v_18: G = __loaded[2];
-                        match __v_16.as_canonical_u64() {
-                          0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_19: G = __loaded[0];
-                            let __v_20: G = __loaded[1];
-                            let __v_21: G = __loaded[2];
-                            match __v_19.as_canonical_u64() {
-                              0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                let __v_22: G = __loaded[0];
-                                let __v_23: G = __loaded[1];
-                                let __v_24: G = __loaded[2];
-                                match __v_22.as_canonical_u64() {
-                                  0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                    let __v_25: G = __loaded[0];
-                                    let __v_26: G = __loaded[1];
-                                    let __v_27: G = __loaded[2];
-                                    match __v_25.as_canonical_u64() {
-                                      0u64 => {
-                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                        let __v_28: G = __loaded[0];
-                                        let __v_29: G = __loaded[1];
-                                        let __v_30: G = __loaded[2];
-                                        match __v_28.as_canonical_u64() {
-                                          0u64 => {
-                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                            let __v_31: G = __loaded[0];
-                                            let __v_32: G = __loaded[1];
-                                            let __v_33: G = __loaded[2];
-                                            match __v_31.as_canonical_u64() {
-                                              0u64 => {
-                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                let __v_34: G = __loaded[0];
-                                                let __v_35: G = __loaded[1];
-                                                let __v_36: G = __loaded[2];
-                                                match __v_34.as_canonical_u64() {
-                                                  0u64 => {
-                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                    let __v_37: G = __loaded[0];
-                                                    let __v_38: G = __loaded[1];
-                                                    let __v_39: G = __loaded[2];
-                                                    match __v_37.as_canonical_u64() {
-                                                      0u64 => {
-                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                        let __v_40: G = __loaded[0];
-                                                        let __v_41: G = __loaded[1];
-                                                        let __v_42: G = __loaded[2];
-                                                        match __v_40.as_canonical_u64() {
-                                                          0u64 => {
-                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                            let __v_43: G = __loaded[0];
-                                                            let __v_44: G = __loaded[1];
-                                                            let __v_45: G = __loaded[2];
-                                                            match __v_43.as_canonical_u64() {
-                                                              0u64 => {
-                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                let __v_46: G = __loaded[0];
-                                                                let __v_47: G = __loaded[1];
-                                                                let __v_48: G = __loaded[2];
-                                                                match __v_46.as_canonical_u64() {
-                                                                  0u64 => {
-                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                    let __v_49: G = __loaded[0];
-                                                                    let __v_50: G = __loaded[1];
-                                                                    let __v_51: G = __loaded[2];
-                                                                    match __v_49.as_canonical_u64() {
-                                                                      0u64 => {
-                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                        let __v_52: G = __loaded[0];
-                                                                        let __v_53: G = __loaded[1];
-                                                                        let __v_54: G = __loaded[2];
-                                                                        match __v_52.as_canonical_u64() {
-                                                                          0u64 => {
-                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                            let __v_55: G = __loaded[0];
-                                                                            let __v_56: G = __loaded[1];
-                                                                            let __v_57: G = __loaded[2];
-                                                                            match __v_55.as_canonical_u64() {
-                                                                              0u64 => {
-                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                let __v_58: G = __loaded[0];
-                                                                                let __v_59: G = __loaded[1];
-                                                                                let __v_60: G = __loaded[2];
-                                                                                match __v_58.as_canonical_u64() {
-                                                                                  0u64 => {
-                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                    let __v_61: G = __loaded[0];
-                                                                                    let __v_62: G = __loaded[1];
-                                                                                    let __v_63: G = __loaded[2];
-                                                                                    match __v_61.as_canonical_u64() {
-                                                                                      0u64 => {
-                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                        let __v_64: G = __loaded[0];
-                                                                                        let __v_65: G = __loaded[1];
-                                                                                        let __v_66: G = __loaded[2];
-                                                                                        match __v_64.as_canonical_u64() {
-                                                                                          0u64 => {
-                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                            let __v_67: G = __loaded[0];
-                                                                                            let __v_68: G = __loaded[1];
-                                                                                            let __v_69: G = __loaded[2];
-                                                                                            match __v_67.as_canonical_u64() {
-                                                                                              0u64 => {
-                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                let __v_70: G = __loaded[0];
-                                                                                                let __v_71: G = __loaded[1];
-                                                                                                let __v_72: G = __loaded[2];
-                                                                                                match __v_70.as_canonical_u64() {
-                                                                                                  0u64 => {
-                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                    let __v_73: G = __loaded[0];
-                                                                                                    let __v_74: G = __loaded[1];
-                                                                                                    let __v_75: G = __loaded[2];
-                                                                                                    match __v_73.as_canonical_u64() {
-                                                                                                      0u64 => {
-                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                        let __v_76: G = __loaded[0];
-                                                                                                        let __v_77: G = __loaded[1];
-                                                                                                        let __v_78: G = __loaded[2];
-                                                                                                        match __v_76.as_canonical_u64() {
-                                                                                                          0u64 => {
-                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                            let __v_79: G = __loaded[0];
-                                                                                                            let __v_80: G = __loaded[1];
-                                                                                                            let __v_81: G = __loaded[2];
-                                                                                                            match __v_79.as_canonical_u64() {
-                                                                                                              0u64 => {
-                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                let __v_82: G = __loaded[0];
-                                                                                                                let __v_83: G = __loaded[1];
-                                                                                                                let __v_84: G = __loaded[2];
-                                                                                                                match __v_82.as_canonical_u64() {
-                                                                                                                  0u64 => {
-                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                    let __v_85: G = __loaded[0];
-                                                                                                                    let __v_86: G = __loaded[1];
-                                                                                                                    let __v_87: G = __loaded[2];
-                                                                                                                    match __v_85.as_canonical_u64() {
-                                                                                                                      0u64 => {
-                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                        let __v_88: G = __loaded[0];
-                                                                                                                        let __v_89: G = __loaded[1];
-                                                                                                                        let __v_90: G = __loaded[2];
-                                                                                                                        match __v_88.as_canonical_u64() {
-                                                                                                                          0u64 => {
-                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                            let __v_91: G = __loaded[0];
-                                                                                                                            let __v_92: G = __loaded[1];
-                                                                                                                            let __v_93: G = __loaded[2];
-                                                                                                                            match __v_91.as_canonical_u64() {
-                                                                                                                              0u64 => {
-                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                let __v_94: G = __loaded[0];
-                                                                                                                                let __v_95: G = __loaded[1];
-                                                                                                                                let __v_96: G = __loaded[2];
-                                                                                                                                match __v_94.as_canonical_u64() {
-                                                                                                                                  0u64 => {
-                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                    let __v_97: G = __loaded[0];
-                                                                                                                                    let __v_98: G = __loaded[1];
-                                                                                                                                    let __v_99: G = __loaded[2];
-                                                                                                                                    match __v_97.as_canonical_u64() {
-                                                                                                                                      0u64 => {
-                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                        let __v_100: G = __loaded[0];
-                                                                                                                                        let __v_101: G = __loaded[1];
-                                                                                                                                        let __v_102: G = __loaded[2];
-                                                                                                                                        match __v_100.as_canonical_u64() {
-                                                                                                                                          0u64 => {
-                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                            let __v_103: G = __loaded[0];
-                                                                                                                                            let __v_104: G = __loaded[1];
-                                                                                                                                            let __v_105: G = __loaded[2];
-                                                                                                                                            match __v_103.as_canonical_u64() {
-                                                                                                                                              0u64 => {
-                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                let __v_106: G = __loaded[0];
-                                                                                                                                                let __v_107: G = __loaded[1];
-                                                                                                                                                let __v_108: G = __loaded[2];
-                                                                                                                                                match __v_106.as_canonical_u64() {
-                                                                                                                                                  0u64 => {
-                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                    let __v_109: G = __loaded[0];
-                                                                                                                                                    let __v_110: G = __loaded[1];
-                                                                                                                                                    let __v_111: G = __loaded[2];
-                                                                                                                                                    match __v_109.as_canonical_u64() {
-                                                                                                                                                      0u64 => {
-                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                        let __v_112: G = __loaded[0];
-                                                                                                                                                        let __v_113: G = __loaded[1];
-                                                                                                                                                        let __v_114: G = __loaded[2];
-                                                                                                                                                        match __v_112.as_canonical_u64() {
-                                                                                                                                                          0u64 => {
-                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                            let __v_115: G = __loaded[0];
-                                                                                                                                                            let __v_116: G = __loaded[1];
-                                                                                                                                                            let __v_117: G = __loaded[2];
-                                                                                                                                                            match __v_115.as_canonical_u64() {
-                                                                                                                                                              0u64 => {
-                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                let __v_118: G = __loaded[0];
-                                                                                                                                                                let __v_119: G = __loaded[1];
-                                                                                                                                                                let __v_120: G = __loaded[2];
-                                                                                                                                                                match __v_118.as_canonical_u64() {
-                                                                                                                                                                  0u64 => {
-                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                    let __v_121: G = __loaded[0];
-                                                                                                                                                                    let __v_122: G = __loaded[1];
-                                                                                                                                                                    let __v_123: G = __loaded[2];
-                                                                                                                                                                    match __v_121.as_canonical_u64() {
-                                                                                                                                                                      0u64 => {
-                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                        let __v_124: G = __loaded[0];
-                                                                                                                                                                        let __v_125: G = __loaded[1];
-                                                                                                                                                                        let __v_126: G = __loaded[2];
-                                                                                                                                                                        match __v_124.as_canonical_u64() {
-                                                                                                                                                                          0u64 => {
-                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                            let __v_127: G = __loaded[0];
-                                                                                                                                                                            let __v_128: G = __loaded[1];
-                                                                                                                                                                            let __v_129: G = __loaded[2];
-                                                                                                                                                                            match __v_127.as_canonical_u64() {
-                                                                                                                                                                              0u64 => {
-                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                let __v_130: G = __loaded[0];
-                                                                                                                                                                                let __v_131: G = __loaded[1];
-                                                                                                                                                                                let __v_132: G = __loaded[2];
-                                                                                                                                                                                match __v_130.as_canonical_u64() {
-                                                                                                                                                                                  0u64 => {
-                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                    let __v_133: G = __loaded[0];
-                                                                                                                                                                                    let __v_134: G = __loaded[1];
-                                                                                                                                                                                    let __v_135: G = __loaded[2];
-                                                                                                                                                                                    match __v_133.as_canonical_u64() {
-                                                                                                                                                                                      0u64 => {
-                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                        let __v_136: G = __loaded[0];
-                                                                                                                                                                                        let __v_137: G = __loaded[1];
-                                                                                                                                                                                        let __v_138: G = __loaded[2];
-                                                                                                                                                                                        match __v_136.as_canonical_u64() {
-                                                                                                                                                                                          0u64 => {
-                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                            let __v_139: G = __loaded[0];
-                                                                                                                                                                                            let __v_140: G = __loaded[1];
-                                                                                                                                                                                            let __v_141: G = __loaded[2];
-                                                                                                                                                                                            match __v_139.as_canonical_u64() {
-                                                                                                                                                                                              0u64 => {
-                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                let __v_142: G = __loaded[0];
-                                                                                                                                                                                                let __v_143: G = __loaded[1];
-                                                                                                                                                                                                let __v_144: G = __loaded[2];
-                                                                                                                                                                                                match __v_142.as_canonical_u64() {
-                                                                                                                                                                                                  0u64 => {
-                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                    let __v_145: G = __loaded[0];
-                                                                                                                                                                                                    let __v_146: G = __loaded[1];
-                                                                                                                                                                                                    let __v_147: G = __loaded[2];
-                                                                                                                                                                                                    match __v_145.as_canonical_u64() {
-                                                                                                                                                                                                      0u64 => {
-                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                        let __v_148: G = __loaded[0];
-                                                                                                                                                                                                        let __v_149: G = __loaded[1];
-                                                                                                                                                                                                        let __v_150: G = __loaded[2];
-                                                                                                                                                                                                        match __v_148.as_canonical_u64() {
-                                                                                                                                                                                                          0u64 => {
-                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                            let __v_151: G = __loaded[0];
-                                                                                                                                                                                                            let __v_152: G = __loaded[1];
-                                                                                                                                                                                                            let __v_153: G = __loaded[2];
-                                                                                                                                                                                                            match __v_151.as_canonical_u64() {
-                                                                                                                                                                                                              0u64 => {
-                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                let __v_154: G = __loaded[0];
-                                                                                                                                                                                                                let __v_155: G = __loaded[1];
-                                                                                                                                                                                                                let __v_156: G = __loaded[2];
-                                                                                                                                                                                                                match __v_154.as_canonical_u64() {
-                                                                                                                                                                                                                  0u64 => {
-                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                    let __v_157: G = __loaded[0];
-                                                                                                                                                                                                                    let __v_158: G = __loaded[1];
-                                                                                                                                                                                                                    let __v_159: G = __loaded[2];
-                                                                                                                                                                                                                    match __v_157.as_canonical_u64() {
-                                                                                                                                                                                                                      0u64 => {
-                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                        let __v_160: G = __loaded[0];
-                                                                                                                                                                                                                        let __v_161: G = __loaded[1];
-                                                                                                                                                                                                                        let __v_162: G = __loaded[2];
-                                                                                                                                                                                                                        match __v_160.as_canonical_u64() {
-                                                                                                                                                                                                                          0u64 => {
-                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                            let __v_163: G = __loaded[0];
-                                                                                                                                                                                                                            let __v_164: G = __loaded[1];
-                                                                                                                                                                                                                            let __v_165: G = __loaded[2];
-                                                                                                                                                                                                                            match __v_163.as_canonical_u64() {
-                                                                                                                                                                                                                              0u64 => {
-                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                let __v_166: G = __loaded[0];
-                                                                                                                                                                                                                                let __v_167: G = __loaded[1];
-                                                                                                                                                                                                                                let __v_168: G = __loaded[2];
-                                                                                                                                                                                                                                match __v_166.as_canonical_u64() {
-                                                                                                                                                                                                                                  0u64 => {
-                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                    let __v_169: G = __loaded[0];
-                                                                                                                                                                                                                                    let __v_170: G = __loaded[1];
-                                                                                                                                                                                                                                    let __v_171: G = __loaded[2];
-                                                                                                                                                                                                                                    match __v_169.as_canonical_u64() {
-                                                                                                                                                                                                                                      0u64 => {
-                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                        let __v_172: G = __loaded[0];
-                                                                                                                                                                                                                                        let __v_173: G = __loaded[1];
-                                                                                                                                                                                                                                        let __v_174: G = __loaded[2];
-                                                                                                                                                                                                                                        match __v_172.as_canonical_u64() {
-                                                                                                                                                                                                                                          0u64 => {
-                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                            let __v_175: G = __loaded[0];
-                                                                                                                                                                                                                                            let __v_176: G = __loaded[1];
-                                                                                                                                                                                                                                            let __v_177: G = __loaded[2];
-                                                                                                                                                                                                                                            match __v_175.as_canonical_u64() {
-                                                                                                                                                                                                                                              0u64 => {
-                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                let __v_178: G = __loaded[0];
-                                                                                                                                                                                                                                                let __v_179: G = __loaded[1];
-                                                                                                                                                                                                                                                let __v_180: G = __loaded[2];
-                                                                                                                                                                                                                                                match __v_178.as_canonical_u64() {
-                                                                                                                                                                                                                                                  0u64 => {
-                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                    let __v_181: G = __loaded[0];
-                                                                                                                                                                                                                                                    let __v_182: G = __loaded[1];
-                                                                                                                                                                                                                                                    let __v_183: G = __loaded[2];
-                                                                                                                                                                                                                                                    match __v_181.as_canonical_u64() {
-                                                                                                                                                                                                                                                      0u64 => {
-                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                        let __v_184: G = __loaded[0];
-                                                                                                                                                                                                                                                        let __v_185: G = __loaded[1];
-                                                                                                                                                                                                                                                        let __v_186: G = __loaded[2];
-                                                                                                                                                                                                                                                        match __v_184.as_canonical_u64() {
-                                                                                                                                                                                                                                                          0u64 => {
-                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                            let __v_187: G = __loaded[0];
-                                                                                                                                                                                                                                                            let __v_188: G = __loaded[1];
-                                                                                                                                                                                                                                                            let __v_189: G = __loaded[2];
-                                                                                                                                                                                                                                                            match __v_187.as_canonical_u64() {
-                                                                                                                                                                                                                                                              0u64 => {
-                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                                let __v_190: G = __loaded[0];
-                                                                                                                                                                                                                                                                let __v_191: G = __loaded[1];
-                                                                                                                                                                                                                                                                let __v_192: G = __loaded[2];
-                                                                                                                                                                                                                                                                match __v_190.as_canonical_u64() {
-                                                                                                                                                                                                                                                                  0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_66] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
-                                                                                                                                                                                                                                                                    if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                                                                                                                                                                                                                                                    return Ok(__ret);
-                                                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64()));
-                                                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                                                }
-                                                                                                                                                                                                                                                              },
-                                                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64()));
-                                                                                                                                                                                                                                                              },
-                                                                                                                                                                                                                                                            }
-                                                                                                                                                                                                                                                          },
-                                                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64()));
-                                                                                                                                                                                                                                                          },
-                                                                                                                                                                                                                                                        }
-                                                                                                                                                                                                                                                      },
-                                                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64()));
-                                                                                                                                                                                                                                                      },
-                                                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64()));
-                                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                                }
-                                                                                                                                                                                                                                              },
-                                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64()));
-                                                                                                                                                                                                                                              },
-                                                                                                                                                                                                                                            }
-                                                                                                                                                                                                                                          },
-                                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64()));
-                                                                                                                                                                                                                                          },
-                                                                                                                                                                                                                                        }
-                                                                                                                                                                                                                                      },
-                                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64()));
-                                                                                                                                                                                                                                      },
-                                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64()));
-                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                }
-                                                                                                                                                                                                                              },
-                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64()));
-                                                                                                                                                                                                                              },
-                                                                                                                                                                                                                            }
-                                                                                                                                                                                                                          },
-                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64()));
-                                                                                                                                                                                                                          },
-                                                                                                                                                                                                                        }
-                                                                                                                                                                                                                      },
-                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64()));
-                                                                                                                                                                                                                      },
-                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64()));
-                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                }
-                                                                                                                                                                                                              },
-                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64()));
-                                                                                                                                                                                                              },
-                                                                                                                                                                                                            }
-                                                                                                                                                                                                          },
-                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64()));
-                                                                                                                                                                                                          },
-                                                                                                                                                                                                        }
-                                                                                                                                                                                                      },
-                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64()));
-                                                                                                                                                                                                      },
-                                                                                                                                                                                                    }
-                                                                                                                                                                                                  },
-                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64()));
-                                                                                                                                                                                                  },
-                                                                                                                                                                                                }
-                                                                                                                                                                                              },
-                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64()));
-                                                                                                                                                                                              },
-                                                                                                                                                                                            }
-                                                                                                                                                                                          },
-                                                                                                                                                                                          _ => {
-                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64()));
-                                                                                                                                                                                          },
-                                                                                                                                                                                        }
-                                                                                                                                                                                      },
-                                                                                                                                                                                      _ => {
-                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64()));
-                                                                                                                                                                                      },
-                                                                                                                                                                                    }
-                                                                                                                                                                                  },
-                                                                                                                                                                                  _ => {
-                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64()));
-                                                                                                                                                                                  },
-                                                                                                                                                                                }
-                                                                                                                                                                              },
-                                                                                                                                                                              _ => {
-                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64()));
-                                                                                                                                                                              },
-                                                                                                                                                                            }
-                                                                                                                                                                          },
-                                                                                                                                                                          _ => {
-                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
-                                                                                                                                                                          },
-                                                                                                                                                                        }
-                                                                                                                                                                      },
-                                                                                                                                                                      _ => {
-                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
-                                                                                                                                                                      },
-                                                                                                                                                                    }
-                                                                                                                                                                  },
-                                                                                                                                                                  _ => {
-                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
-                                                                                                                                                                  },
-                                                                                                                                                                }
-                                                                                                                                                              },
-                                                                                                                                                              _ => {
-                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
-                                                                                                                                                              },
-                                                                                                                                                            }
-                                                                                                                                                          },
-                                                                                                                                                          _ => {
-                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
-                                                                                                                                                          },
-                                                                                                                                                        }
-                                                                                                                                                      },
-                                                                                                                                                      _ => {
-                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
-                                                                                                                                                      },
-                                                                                                                                                    }
-                                                                                                                                                  },
-                                                                                                                                                  _ => {
-                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
-                                                                                                                                                  },
-                                                                                                                                                }
-                                                                                                                                              },
-                                                                                                                                              _ => {
-                                                                                                                                                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
-                                                                                                                                              },
-                                                                                                                                            }
-                                                                                                                                          },
-                                                                                                                                          _ => {
-                                                                                                                                            return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64()));
-                                                                                                                                          },
-                                                                                                                                        }
-                                                                                                                                      },
-                                                                                                                                      _ => {
-                                                                                                                                        return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64()));
-                                                                                                                                      },
-                                                                                                                                    }
-                                                                                                                                  },
-                                                                                                                                  _ => {
-                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
-                                                                                                                                  },
-                                                                                                                                }
-                                                                                                                              },
-                                                                                                                              _ => {
-                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
-                                                                                                                              },
-                                                                                                                            }
-                                                                                                                          },
-                                                                                                                          _ => {
-                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
-                                                                                                                          },
-                                                                                                                        }
-                                                                                                                      },
-                                                                                                                      _ => {
-                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
-                                                                                                                      },
-                                                                                                                    }
-                                                                                                                  },
-                                                                                                                  _ => {
-                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
-                                                                                                                  },
-                                                                                                                }
-                                                                                                              },
-                                                                                                              _ => {
-                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
-                                                                                                              },
-                                                                                                            }
-                                                                                                          },
-                                                                                                          _ => {
-                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
-                                                                                                          },
-                                                                                                        }
-                                                                                                      },
-                                                                                                      _ => {
-                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
-                                                                                                      },
-                                                                                                    }
-                                                                                                  },
-                                                                                                  _ => {
-                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
-                                                                                                  },
-                                                                                                }
-                                                                                              },
-                                                                                              _ => {
-                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
-                                                                                              },
-                                                                                            }
-                                                                                          },
-                                                                                          _ => {
-                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
-                                                                                          },
-                                                                                        }
-                                                                                      },
-                                                                                      _ => {
-                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                                                                                      },
-                                                                                    }
-                                                                                  },
-                                                                                  _ => {
-                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
-                                                                                  },
-                                                                                }
-                                                                              },
-                                                                              _ => {
-                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
-                                                                              },
-                                                                            }
-                                                                          },
-                                                                          _ => {
-                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
-                                                                          },
-                                                                        }
-                                                                      },
-                                                                      _ => {
-                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
-                                                                      },
-                                                                    }
-                                                                  },
-                                                                  _ => {
-                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
-                                                                  },
-                                                                }
-                                                              },
-                                                              _ => {
-                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
-                                                              },
-                                                            }
-                                                          },
-                                                          _ => {
-                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
-                                                          },
-                                                        }
-                                                      },
-                                                      _ => {
-                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
-                                                      },
-                                                    }
-                                                  },
-                                                  _ => {
-                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
-                                                  },
-                                                }
-                                              },
-                                              _ => {
-                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
-                                              },
-                                            }
-                                          },
-                                          _ => {
-                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
-                                          },
-                                        }
-                                      },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_67: usize = 2;
-const IN_67: usize = 2;
-const OUT_67: usize = 1;
-fn aiur_fn_67(
-  inp: [G; IN_67],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_67], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_67] = [__v_0];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_2: G = G::from_u64(0);
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = (__v_1 - __v_5);
-        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_67] = [__v_7];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_68: usize = 6;
-const IN_68: usize = 6;
-const OUT_68: usize = 1;
-fn aiur_fn_68(
-  inp: [G; IN_68],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_68], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = G::from_u64(2);
-    let __v_8: G = G::from_u64(8);
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-            let __v_9: G = __loaded[0];
-            let __v_10: G = __loaded[1];
-            let __v_11: G = __loaded[2];
-            let __v_12: G = __loaded[3];
-            let __v_13: G = __loaded[4];
-            let __v_14: G = __loaded[5];
-            let __v_15: G = __loaded[6];
-            let __v_16: G = __loaded[7];
-            match __v_9.as_canonical_u64() {
-              0u64 => {
-                match __v_10.as_canonical_u64() {
-                  0u64 => {
-                    match __v_11.as_canonical_u64() {
-                      0u64 => {
-                        match __v_12.as_canonical_u64() {
-                          0u64 => {
-                            match __v_13.as_canonical_u64() {
-                              0u64 => {
-                                match __v_14.as_canonical_u64() {
-                                  0u64 => {
-                                    match __v_15.as_canonical_u64() {
-                                      0u64 => {
-                                        match __v_16.as_canonical_u64() {
-                                          0u64 => {
-                                            let __v_17: G = (__v_6 + __v_7);
-                                            let __v_18: G = (__v_8 + __v_17);
-                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-                                            let __v_19: G = __loaded[0];
-                                            let __v_20: G = __loaded[1];
-                                            let __v_21: G = __loaded[2];
-                                            let __v_22: G = __loaded[3];
-                                            let __v_23: G = __loaded[4];
-                                            let __v_24: G = __loaded[5];
-                                            let __v_25: G = __loaded[6];
-                                            let __v_26: G = __loaded[7];
-                                            let __v_27: G = __loaded[8];
-                                            let __v_28: G = __loaded[9];
-                                            let __v_29: G = __loaded[10];
-                                            let __v_30: G = __loaded[11];
-                                            let __v_31: G = __loaded[12];
-                                            let __v_32: G = __loaded[13];
-                                            let __v_33: G = __loaded[14];
-                                            let __v_34: G = __loaded[15];
-                                            let __v_35: G = __loaded[16];
-                                            let __v_36: G = __loaded[17];
-                                            let __v_37: G = __loaded[18];
-                                            let __v_38: G = __loaded[19];
-                                            let __v_39: G = __loaded[20];
-                                            let __v_40: G = __loaded[21];
-                                            let __v_41: G = __loaded[22];
-                                            let __v_42: G = __loaded[23];
-                                            let __v_43: G = __loaded[24];
-                                            let __v_44: G = __loaded[25];
-                                            let __v_45: G = __loaded[26];
-                                            let __v_46: G = __loaded[27];
-                                            let __v_47: G = __loaded[28];
-                                            let __v_48: G = __loaded[29];
-                                            let __v_49: G = __loaded[30];
-                                            let __v_50: G = __loaded[31];
-                                            let __v_51: G = G::from_u64(0);
-                                            let __v_52: G = G::from_u64(0);
-                                            let __v_53: G = G::from_u64(0);
-                                            let __v_54: G = G::from_u64(0);
-                                            let __v_55: G = G::from_u64(0);
-                                            let __v_56: G = G::from_u64(0);
-                                            let __v_57: G = G::from_u64(0);
-                                            let __v_58: G = G::from_u64(0);
-                                            let __v_59: G = G::from_u64(0);
-                                            let __v_60: G = G::from_u64(0);
-                                            let __v_61: G = G::from_u64(0);
-                                            let __v_62: G = G::from_u64(0);
-                                            let __v_63: G = G::from_u64(0);
-                                            let __v_64: G = G::from_u64(0);
-                                            let __v_65: G = G::from_u64(0);
-                                            let __v_66: G = G::from_u64(0);
-                                            let __v_67: G = G::from_u64(0);
-                                            let __v_68: G = G::from_u64(0);
-                                            let __v_69: G = G::from_u64(0);
-                                            let __v_70: G = G::from_u64(0);
-                                            let __v_71: G = G::from_u64(0);
-                                            let __v_72: G = G::from_u64(0);
-                                            let __v_73: G = G::from_u64(0);
-                                            let __v_74: G = G::from_u64(0);
-                                            let __v_75: G = G::from_u64(0);
-                                            let __v_76: G = G::from_u64(0);
-                                            let __v_77: G = G::from_u64(0);
-                                            let __v_78: G = G::from_u64(0);
-                                            let __v_79: G = G::from_u64(0);
-                                            let __v_80: G = G::from_u64(0);
-                                            let __v_81: G = G::from_u64(0);
-                                            let __v_82: G = G::from_u64(0);
-                                            let __v_83: G = G::from_u64(0);
-                                            let __v_84: G = G::from_u64(0);
-                                            let __v_85: G = G::from_u64(0);
-                                            let __v_86: G = G::from_u64(0);
-                                            let __v_87: G = G::from_u64(0);
-                                            let __v_88: G = G::from_u64(0);
-                                            let __v_89: G = G::from_u64(0);
-                                            let __v_90: G = G::from_u64(0);
-                                            let __v_91: G = G::from_u64(0);
-                                            let __v_92: G = G::from_u64(0);
-                                            let __v_93: G = G::from_u64(0);
-                                            let __v_94: G = G::from_u64(0);
-                                            let __v_95: G = G::from_u64(0);
-                                            let __v_96: G = G::from_u64(0);
-                                            let __v_97: G = G::from_u64(0);
-                                            let __v_98: G = G::from_u64(0);
-                                            let __v_99: G = G::from_u64(0);
-                                            let __v_100: G = G::from_u64(0);
-                                            let __v_101: G = G::from_u64(0);
-                                            let __v_102: G = G::from_u64(0);
-                                            let __v_103: G = G::from_u64(0);
-                                            let __v_104: G = G::from_u64(0);
-                                            let __v_105: G = G::from_u64(0);
-                                            let __v_106: G = G::from_u64(0);
-                                            let __v_107: G = G::from_u64(0);
-                                            let __v_108: G = G::from_u64(0);
-                                            let __v_109: G = G::from_u64(0);
-                                            let __v_110: G = G::from_u64(0);
-                                            let __v_111: G = G::from_u64(0);
-                                            let __v_112: G = G::from_u64(0);
-                                            let __v_113: G = G::from_u64(0);
-                                            let __v_114: G = G::from_u64(0);
-                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-                                            let __v_115: G = __loaded[0];
-                                            let __v_116: G = __loaded[1];
-                                            let __v_117: G = __loaded[2];
-                                            let __v_118: G = __loaded[3];
-                                            let __v_119: G = __loaded[4];
-                                            let __v_120: G = __loaded[5];
-                                            let __v_121: G = __loaded[6];
-                                            let __v_122: G = __loaded[7];
-                                            let __v_123: G = G::from_u64(0);
-                                            let __v_124: G = G::from_u64(103);
-                                            let __v_125: G = G::from_u64(230);
-                                            let __v_126: G = G::from_u64(9);
-                                            let __v_127: G = G::from_u64(106);
-                                            let __v_128: G = G::from_u64(133);
-                                            let __v_129: G = G::from_u64(174);
-                                            let __v_130: G = G::from_u64(103);
-                                            let __v_131: G = G::from_u64(187);
-                                            let __v_132: G = G::from_u64(114);
-                                            let __v_133: G = G::from_u64(243);
-                                            let __v_134: G = G::from_u64(110);
-                                            let __v_135: G = G::from_u64(60);
-                                            let __v_136: G = G::from_u64(58);
-                                            let __v_137: G = G::from_u64(245);
-                                            let __v_138: G = G::from_u64(79);
-                                            let __v_139: G = G::from_u64(165);
-                                            let __v_140: G = G::from_u64(0);
-                                            let __v_141: G = G::from_u64(0);
-                                            let __v_142: G = G::from_u64(0);
-                                            let __v_143: G = G::from_u64(0);
-                                            let __v_144: G = G::from_u64(0);
-                                            let __v_145: G = G::from_u64(0);
-                                            let __v_146: G = G::from_u64(0);
-                                            let __v_147: G = G::from_u64(0);
-                                            let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-                                            let __v_148: G = __r_arr[0];
-                                            let __v_149: G = __r_arr[1];
-                                            let __v_150: G = __r_arr[2];
-                                            let __v_151: G = __r_arr[3];
-                                            let __v_152: G = __r_arr[4];
-                                            let __v_153: G = __r_arr[5];
-                                            let __v_154: G = __r_arr[6];
-                                            let __v_155: G = __r_arr[7];
-                                            let __v_156: G = __r_arr[8];
-                                            let __v_157: G = __r_arr[9];
-                                            let __v_158: G = __r_arr[10];
-                                            let __v_159: G = __r_arr[11];
-                                            let __v_160: G = __r_arr[12];
-                                            let __v_161: G = __r_arr[13];
-                                            let __v_162: G = __r_arr[14];
-                                            let __v_163: G = __r_arr[15];
-                                            let __v_164: G = __r_arr[16];
-                                            let __v_165: G = __r_arr[17];
-                                            let __v_166: G = __r_arr[18];
-                                            let __v_167: G = __r_arr[19];
-                                            let __v_168: G = __r_arr[20];
-                                            let __v_169: G = __r_arr[21];
-                                            let __v_170: G = __r_arr[22];
-                                            let __v_171: G = __r_arr[23];
-                                            let __v_172: G = __r_arr[24];
-                                            let __v_173: G = __r_arr[25];
-                                            let __v_174: G = __r_arr[26];
-                                            let __v_175: G = __r_arr[27];
-                                            let __v_176: G = __r_arr[28];
-                                            let __v_177: G = __r_arr[29];
-                                            let __v_178: G = __r_arr[30];
-                                            let __v_179: G = __r_arr[31];
-                                            let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_68] = [__v_180];
-                                            if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                            return Ok(__ret);
-                                          },
-                                          _ => {
-                                            let __ret: [G; OUT_68] = [__v_5];
-                                            if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                            return Ok(__ret);
-                                          },
-                                        }
-                                      },
-                                      _ => {
-                                        let __ret: [G; OUT_68] = [__v_5];
-                                        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                        return Ok(__ret);
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    let __ret: [G; OUT_68] = [__v_5];
-                                    if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                    return Ok(__ret);
-                                  },
-                                }
-                              },
-                              _ => {
-                                let __ret: [G; OUT_68] = [__v_5];
-                                if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                return Ok(__ret);
-                              },
-                            }
-                          },
-                          _ => {
-                            let __ret: [G; OUT_68] = [__v_5];
-                            if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        let __ret: [G; OUT_68] = [__v_5];
-                        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    let __ret: [G; OUT_68] = [__v_5];
-                    if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __ret: [G; OUT_68] = [__v_5];
-                if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __v_9: G = G::from_u64(0);
-            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-            let __v_10: G = __loaded[0];
-            let __v_11: G = __loaded[1];
-            let __v_12: G = __loaded[2];
-            let __v_13: G = __loaded[3];
-            let __v_14: G = __loaded[4];
-            let __v_15: G = __loaded[5];
-            let __v_16: G = __loaded[6];
-            let __v_17: G = __loaded[7];
-            let __v_18: G = __loaded[8];
-            let __v_19: G = __loaded[9];
-            let __v_20: G = __loaded[10];
-            let __v_21: G = __loaded[11];
-            let __v_22: G = __loaded[12];
-            let __v_23: G = __loaded[13];
-            let __v_24: G = __loaded[14];
-            let __v_25: G = __loaded[15];
-            let __v_26: G = __loaded[16];
-            let __v_27: G = __loaded[17];
-            let __v_28: G = __loaded[18];
-            let __v_29: G = __loaded[19];
-            let __v_30: G = __loaded[20];
-            let __v_31: G = __loaded[21];
-            let __v_32: G = __loaded[22];
-            let __v_33: G = __loaded[23];
-            let __v_34: G = __loaded[24];
-            let __v_35: G = __loaded[25];
-            let __v_36: G = __loaded[26];
-            let __v_37: G = __loaded[27];
-            let __v_38: G = __loaded[28];
-            let __v_39: G = __loaded[29];
-            let __v_40: G = __loaded[30];
-            let __v_41: G = __loaded[31];
-            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_68] = [__v_42];
-            if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        let __v_13: G = __loaded[4];
-        let __v_14: G = __loaded[5];
-        let __v_15: G = __loaded[6];
-        let __v_16: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = (__v_17 * __v_8);
-        let __v_19: G = (__v_2 - __v_1);
-        let __v_20: G = G::from_bool((__v_19 == G::ZERO));
-        let __v_21: G = (__v_20 * __v_6);
-        let __v_22: G = (__v_18 + __v_21);
-        let __v_23: G = (__v_7 + __v_22);
-        let __v_24: G = G::from_u64(64);
-        let __v_25: G = (__v_24 - __v_1);
-        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = __r_arr[1];
-        let __v_29: G = __r_arr[2];
-        let __v_30: G = __r_arr[3];
-        let __v_31: G = __r_arr[4];
-        let __v_32: G = __r_arr[5];
-        let __v_33: G = __r_arr[6];
-        let __v_34: G = __r_arr[7];
-        let __v_35: G = __r_arr[8];
-        let __v_36: G = __r_arr[9];
-        let __v_37: G = __r_arr[10];
-        let __v_38: G = __r_arr[11];
-        let __v_39: G = __r_arr[12];
-        let __v_40: G = __r_arr[13];
-        let __v_41: G = __r_arr[14];
-        let __v_42: G = __r_arr[15];
-        let __v_43: G = __r_arr[16];
-        let __v_44: G = __r_arr[17];
-        let __v_45: G = __r_arr[18];
-        let __v_46: G = __r_arr[19];
-        let __v_47: G = __r_arr[20];
-        let __v_48: G = __r_arr[21];
-        let __v_49: G = __r_arr[22];
-        let __v_50: G = __r_arr[23];
-        let __v_51: G = __r_arr[24];
-        let __v_52: G = __r_arr[25];
-        let __v_53: G = __r_arr[26];
-        let __v_54: G = __r_arr[27];
-        let __v_55: G = __r_arr[28];
-        let __v_56: G = __r_arr[29];
-        let __v_57: G = __r_arr[30];
-        let __v_58: G = __r_arr[31];
-        let __v_59: G = __r_arr[32];
-        let __v_60: G = __r_arr[33];
-        let __v_61: G = __r_arr[34];
-        let __v_62: G = __r_arr[35];
-        let __v_63: G = __r_arr[36];
-        let __v_64: G = __r_arr[37];
-        let __v_65: G = __r_arr[38];
-        let __v_66: G = __r_arr[39];
-        let __v_67: G = __r_arr[40];
-        let __v_68: G = __r_arr[41];
-        let __v_69: G = __r_arr[42];
-        let __v_70: G = __r_arr[43];
-        let __v_71: G = __r_arr[44];
-        let __v_72: G = __r_arr[45];
-        let __v_73: G = __r_arr[46];
-        let __v_74: G = __r_arr[47];
-        let __v_75: G = __r_arr[48];
-        let __v_76: G = __r_arr[49];
-        let __v_77: G = __r_arr[50];
-        let __v_78: G = __r_arr[51];
-        let __v_79: G = __r_arr[52];
-        let __v_80: G = __r_arr[53];
-        let __v_81: G = __r_arr[54];
-        let __v_82: G = __r_arr[55];
-        let __v_83: G = __r_arr[56];
-        let __v_84: G = __r_arr[57];
-        let __v_85: G = __r_arr[58];
-        let __v_86: G = __r_arr[59];
-        let __v_87: G = __r_arr[60];
-        let __v_88: G = __r_arr[61];
-        let __v_89: G = __r_arr[62];
-        let __v_90: G = __r_arr[63];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_91: G = __loaded[0];
-        let __v_92: G = __loaded[1];
-        let __v_93: G = __loaded[2];
-        let __v_94: G = __loaded[3];
-        let __v_95: G = __loaded[4];
-        let __v_96: G = __loaded[5];
-        let __v_97: G = __loaded[6];
-        let __v_98: G = __loaded[7];
-        let __v_99: G = __loaded[8];
-        let __v_100: G = __loaded[9];
-        let __v_101: G = __loaded[10];
-        let __v_102: G = __loaded[11];
-        let __v_103: G = __loaded[12];
-        let __v_104: G = __loaded[13];
-        let __v_105: G = __loaded[14];
-        let __v_106: G = __loaded[15];
-        let __v_107: G = __loaded[16];
-        let __v_108: G = __loaded[17];
-        let __v_109: G = __loaded[18];
-        let __v_110: G = __loaded[19];
-        let __v_111: G = __loaded[20];
-        let __v_112: G = __loaded[21];
-        let __v_113: G = __loaded[22];
-        let __v_114: G = __loaded[23];
-        let __v_115: G = __loaded[24];
-        let __v_116: G = __loaded[25];
-        let __v_117: G = __loaded[26];
-        let __v_118: G = __loaded[27];
-        let __v_119: G = __loaded[28];
-        let __v_120: G = __loaded[29];
-        let __v_121: G = __loaded[30];
-        let __v_122: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_123: G = __loaded[0];
-        let __v_124: G = __loaded[1];
-        let __v_125: G = __loaded[2];
-        let __v_126: G = __loaded[3];
-        let __v_127: G = __loaded[4];
-        let __v_128: G = __loaded[5];
-        let __v_129: G = __loaded[6];
-        let __v_130: G = __loaded[7];
-        let __v_131: G = G::from_u64(103);
-        let __v_132: G = G::from_u64(230);
-        let __v_133: G = G::from_u64(9);
-        let __v_134: G = G::from_u64(106);
-        let __v_135: G = G::from_u64(133);
-        let __v_136: G = G::from_u64(174);
-        let __v_137: G = G::from_u64(103);
-        let __v_138: G = G::from_u64(187);
-        let __v_139: G = G::from_u64(114);
-        let __v_140: G = G::from_u64(243);
-        let __v_141: G = G::from_u64(110);
-        let __v_142: G = G::from_u64(60);
-        let __v_143: G = G::from_u64(58);
-        let __v_144: G = G::from_u64(245);
-        let __v_145: G = G::from_u64(79);
-        let __v_146: G = G::from_u64(165);
-        let __v_147: G = G::from_u64(0);
-        let __v_148: G = G::from_u64(0);
-        let __v_149: G = G::from_u64(0);
-        let __v_150: G = G::from_u64(0);
-        let __v_151: G = G::from_u64(0);
-        let __v_152: G = G::from_u64(0);
-        let __v_153: G = G::from_u64(0);
-        let __v_154: G = G::from_u64(0);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-        let __v_155: G = __r_arr[0];
-        let __v_156: G = __r_arr[1];
-        let __v_157: G = __r_arr[2];
-        let __v_158: G = __r_arr[3];
-        let __v_159: G = __r_arr[4];
-        let __v_160: G = __r_arr[5];
-        let __v_161: G = __r_arr[6];
-        let __v_162: G = __r_arr[7];
-        let __v_163: G = __r_arr[8];
-        let __v_164: G = __r_arr[9];
-        let __v_165: G = __r_arr[10];
-        let __v_166: G = __r_arr[11];
-        let __v_167: G = __r_arr[12];
-        let __v_168: G = __r_arr[13];
-        let __v_169: G = __r_arr[14];
-        let __v_170: G = __r_arr[15];
-        let __v_171: G = __r_arr[16];
-        let __v_172: G = __r_arr[17];
-        let __v_173: G = __r_arr[18];
-        let __v_174: G = __r_arr[19];
-        let __v_175: G = __r_arr[20];
-        let __v_176: G = __r_arr[21];
-        let __v_177: G = __r_arr[22];
-        let __v_178: G = __r_arr[23];
-        let __v_179: G = __r_arr[24];
-        let __v_180: G = __r_arr[25];
-        let __v_181: G = __r_arr[26];
-        let __v_182: G = __r_arr[27];
-        let __v_183: G = __r_arr[28];
-        let __v_184: G = __r_arr[29];
-        let __v_185: G = __r_arr[30];
-        let __v_186: G = __r_arr[31];
-        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_68] = [__v_187];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_69: usize = 6;
-const IN_69: usize = 6;
-const OUT_69: usize = 1;
-fn aiur_fn_69(
-  inp: [G; IN_69],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_69], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = G::from_u64(2);
-    let __v_8: G = G::from_u64(8);
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __v_11: G = __r_arr[2];
-    let __v_12: G = __r_arr[3];
-    let __v_13: G = __r_arr[4];
-    let __v_14: G = __r_arr[5];
-    let __v_15: G = __r_arr[6];
-    let __v_16: G = __r_arr[7];
-    let __v_17: G = __r_arr[8];
-    let __v_18: G = __r_arr[9];
-    let __v_19: G = __r_arr[10];
-    let __v_20: G = __r_arr[11];
-    let __v_21: G = __r_arr[12];
-    let __v_22: G = __r_arr[13];
-    let __v_23: G = __r_arr[14];
-    let __v_24: G = __r_arr[15];
-    let __v_25: G = __r_arr[16];
-    let __v_26: G = __r_arr[17];
-    let __v_27: G = __r_arr[18];
-    let __v_28: G = __r_arr[19];
-    let __v_29: G = __r_arr[20];
-    let __v_30: G = __r_arr[21];
-    let __v_31: G = __r_arr[22];
-    let __v_32: G = __r_arr[23];
-    let __v_33: G = __r_arr[24];
-    let __v_34: G = __r_arr[25];
-    let __v_35: G = __r_arr[26];
-    let __v_36: G = __r_arr[27];
-    let __v_37: G = __r_arr[28];
-    let __v_38: G = __r_arr[29];
-    let __v_39: G = __r_arr[30];
-    let __v_40: G = __r_arr[31];
-    let __v_41: G = __r_arr[32];
-    let __v_42: G = __r_arr[33];
-    let __v_43: G = __r_arr[34];
-    let __v_44: G = __r_arr[35];
-    let __v_45: G = __r_arr[36];
-    let __v_46: G = __r_arr[37];
-    let __v_47: G = __r_arr[38];
-    let __v_48: G = __r_arr[39];
-    let __v_49: G = __r_arr[40];
-    let __v_50: G = __r_arr[41];
-    let __v_51: G = __r_arr[42];
-    let __v_52: G = __r_arr[43];
-    let __v_53: G = __r_arr[44];
-    let __v_54: G = __r_arr[45];
-    let __v_55: G = __r_arr[46];
-    let __v_56: G = __r_arr[47];
-    let __v_57: G = __r_arr[48];
-    let __v_58: G = __r_arr[49];
-    let __v_59: G = __r_arr[50];
-    let __v_60: G = __r_arr[51];
-    let __v_61: G = __r_arr[52];
-    let __v_62: G = __r_arr[53];
-    let __v_63: G = __r_arr[54];
-    let __v_64: G = __r_arr[55];
-    let __v_65: G = __r_arr[56];
-    let __v_66: G = __r_arr[57];
-    let __v_67: G = __r_arr[58];
-    let __v_68: G = __r_arr[59];
-    let __v_69: G = __r_arr[60];
-    let __v_70: G = __r_arr[61];
-    let __v_71: G = __r_arr[62];
-    let __v_72: G = __r_arr[63];
-    match __v_2.as_canonical_u64() {
-      1023u64 => {
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
-        let __v_73: G = __r_arr[0];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_74: G = __loaded[0];
-        let __v_75: G = __loaded[1];
-        let __v_76: G = __loaded[2];
-        let __v_77: G = __loaded[3];
-        let __v_78: G = __loaded[4];
-        let __v_79: G = __loaded[5];
-        let __v_80: G = __loaded[6];
-        let __v_81: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_82: G = __r_arr[0];
-        let __v_83: G = (__v_73 * __v_82);
-        let __v_84: G = (__v_8 * __v_83);
-        let __v_85: G = (__v_84 + __v_7);
-        let __v_86: G = G::from_u64(103);
-        let __v_87: G = G::from_u64(230);
-        let __v_88: G = G::from_u64(9);
-        let __v_89: G = G::from_u64(106);
-        let __v_90: G = G::from_u64(133);
-        let __v_91: G = G::from_u64(174);
-        let __v_92: G = G::from_u64(103);
-        let __v_93: G = G::from_u64(187);
-        let __v_94: G = G::from_u64(114);
-        let __v_95: G = G::from_u64(243);
-        let __v_96: G = G::from_u64(110);
-        let __v_97: G = G::from_u64(60);
-        let __v_98: G = G::from_u64(58);
-        let __v_99: G = G::from_u64(245);
-        let __v_100: G = G::from_u64(79);
-        let __v_101: G = G::from_u64(165);
-        let __v_102: G = G::from_u64(127);
-        let __v_103: G = G::from_u64(82);
-        let __v_104: G = G::from_u64(14);
-        let __v_105: G = G::from_u64(81);
-        let __v_106: G = G::from_u64(140);
-        let __v_107: G = G::from_u64(104);
-        let __v_108: G = G::from_u64(5);
-        let __v_109: G = G::from_u64(155);
-        let __v_110: G = G::from_u64(171);
-        let __v_111: G = G::from_u64(217);
-        let __v_112: G = G::from_u64(131);
-        let __v_113: G = G::from_u64(31);
-        let __v_114: G = G::from_u64(25);
-        let __v_115: G = G::from_u64(205);
-        let __v_116: G = G::from_u64(224);
-        let __v_117: G = G::from_u64(91);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_118: G = __loaded[0];
-        let __v_119: G = __loaded[1];
-        let __v_120: G = __loaded[2];
-        let __v_121: G = __loaded[3];
-        let __v_122: G = __loaded[4];
-        let __v_123: G = __loaded[5];
-        let __v_124: G = __loaded[6];
-        let __v_125: G = __loaded[7];
-        let __v_126: G = __loaded[8];
-        let __v_127: G = __loaded[9];
-        let __v_128: G = __loaded[10];
-        let __v_129: G = __loaded[11];
-        let __v_130: G = __loaded[12];
-        let __v_131: G = __loaded[13];
-        let __v_132: G = __loaded[14];
-        let __v_133: G = __loaded[15];
-        let __v_134: G = __loaded[16];
-        let __v_135: G = __loaded[17];
-        let __v_136: G = __loaded[18];
-        let __v_137: G = __loaded[19];
-        let __v_138: G = __loaded[20];
-        let __v_139: G = __loaded[21];
-        let __v_140: G = __loaded[22];
-        let __v_141: G = __loaded[23];
-        let __v_142: G = __loaded[24];
-        let __v_143: G = __loaded[25];
-        let __v_144: G = __loaded[26];
-        let __v_145: G = __loaded[27];
-        let __v_146: G = __loaded[28];
-        let __v_147: G = __loaded[29];
-        let __v_148: G = __loaded[30];
-        let __v_149: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_150: G = __loaded[0];
-        let __v_151: G = __loaded[1];
-        let __v_152: G = __loaded[2];
-        let __v_153: G = __loaded[3];
-        let __v_154: G = __loaded[4];
-        let __v_155: G = __loaded[5];
-        let __v_156: G = __loaded[6];
-        let __v_157: G = __loaded[7];
-        let __v_158: G = G::from_u64(64);
-        let __v_159: G = G::from_u64(103);
-        let __v_160: G = G::from_u64(230);
-        let __v_161: G = G::from_u64(9);
-        let __v_162: G = G::from_u64(106);
-        let __v_163: G = G::from_u64(133);
-        let __v_164: G = G::from_u64(174);
-        let __v_165: G = G::from_u64(103);
-        let __v_166: G = G::from_u64(187);
-        let __v_167: G = G::from_u64(114);
-        let __v_168: G = G::from_u64(243);
-        let __v_169: G = G::from_u64(110);
-        let __v_170: G = G::from_u64(60);
-        let __v_171: G = G::from_u64(58);
-        let __v_172: G = G::from_u64(245);
-        let __v_173: G = G::from_u64(79);
-        let __v_174: G = G::from_u64(165);
-        let __v_175: G = G::from_u64(0);
-        let __v_176: G = G::from_u64(0);
-        let __v_177: G = G::from_u64(0);
-        let __v_178: G = G::from_u64(0);
-        let __v_179: G = G::from_u64(0);
-        let __v_180: G = G::from_u64(0);
-        let __v_181: G = G::from_u64(0);
-        let __v_182: G = G::from_u64(0);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-        let __v_183: G = __r_arr[0];
-        let __v_184: G = __r_arr[1];
-        let __v_185: G = __r_arr[2];
-        let __v_186: G = __r_arr[3];
-        let __v_187: G = __r_arr[4];
-        let __v_188: G = __r_arr[5];
-        let __v_189: G = __r_arr[6];
-        let __v_190: G = __r_arr[7];
-        let __v_191: G = __r_arr[8];
-        let __v_192: G = __r_arr[9];
-        let __v_193: G = __r_arr[10];
-        let __v_194: G = __r_arr[11];
-        let __v_195: G = __r_arr[12];
-        let __v_196: G = __r_arr[13];
-        let __v_197: G = __r_arr[14];
-        let __v_198: G = __r_arr[15];
-        let __v_199: G = __r_arr[16];
-        let __v_200: G = __r_arr[17];
-        let __v_201: G = __r_arr[18];
-        let __v_202: G = __r_arr[19];
-        let __v_203: G = __r_arr[20];
-        let __v_204: G = __r_arr[21];
-        let __v_205: G = __r_arr[22];
-        let __v_206: G = __r_arr[23];
-        let __v_207: G = __r_arr[24];
-        let __v_208: G = __r_arr[25];
-        let __v_209: G = __r_arr[26];
-        let __v_210: G = __r_arr[27];
-        let __v_211: G = __r_arr[28];
-        let __v_212: G = __r_arr[29];
-        let __v_213: G = __r_arr[30];
-        let __v_214: G = __r_arr[31];
-        let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_216: G = G::from_u64(1);
-        let __v_217: G = G::from_u64(1);
-        let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_219: G = G::from_u64(0);
-        let __v_220: G = G::from_u64(0);
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_221: G = __loaded[0];
-        let __v_222: G = __loaded[1];
-        let __v_223: G = __loaded[2];
-        let __v_224: G = __loaded[3];
-        let __v_225: G = __loaded[4];
-        let __v_226: G = __loaded[5];
-        let __v_227: G = __loaded[6];
-        let __v_228: G = __loaded[7];
-        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
-        let __v_229: G = __r_arr[0];
-        let __v_230: G = __r_arr[1];
-        let __v_231: G = __r_arr[2];
-        let __v_232: G = __r_arr[3];
-        let __v_233: G = __r_arr[4];
-        let __v_234: G = __r_arr[5];
-        let __v_235: G = __r_arr[6];
-        let __v_236: G = __r_arr[7];
-        let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-        let __v_239: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_239];
-        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
-        let __v_73: G = __r_arr[0];
-        let __v_74: G = (__v_73 * __v_7);
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
-        let __v_75: G = __r_arr[0];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_76: G = __loaded[0];
-        let __v_77: G = __loaded[1];
-        let __v_78: G = __loaded[2];
-        let __v_79: G = __loaded[3];
-        let __v_80: G = __loaded[4];
-        let __v_81: G = __loaded[5];
-        let __v_82: G = __loaded[6];
-        let __v_83: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_84: G = __r_arr[0];
-        let __v_85: G = (__v_84 * __v_8);
-        let __v_86: G = (__v_75 * __v_85);
-        let __v_87: G = G::from_u64(63);
-        let __v_88: G = (__v_2 - __v_87);
-        let __v_89: G = G::from_bool((__v_88 == G::ZERO));
-        let __v_90: G = (__v_89 * __v_6);
-        let __v_91: G = (__v_86 + __v_90);
-        let __v_92: G = (__v_74 + __v_91);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_93: G = __loaded[0];
-        let __v_94: G = __loaded[1];
-        let __v_95: G = __loaded[2];
-        let __v_96: G = __loaded[3];
-        let __v_97: G = __loaded[4];
-        let __v_98: G = __loaded[5];
-        let __v_99: G = __loaded[6];
-        let __v_100: G = __loaded[7];
-        let __v_101: G = __loaded[8];
-        let __v_102: G = __loaded[9];
-        let __v_103: G = __loaded[10];
-        let __v_104: G = __loaded[11];
-        let __v_105: G = __loaded[12];
-        let __v_106: G = __loaded[13];
-        let __v_107: G = __loaded[14];
-        let __v_108: G = __loaded[15];
-        let __v_109: G = __loaded[16];
-        let __v_110: G = __loaded[17];
-        let __v_111: G = __loaded[18];
-        let __v_112: G = __loaded[19];
-        let __v_113: G = __loaded[20];
-        let __v_114: G = __loaded[21];
-        let __v_115: G = __loaded[22];
-        let __v_116: G = __loaded[23];
-        let __v_117: G = __loaded[24];
-        let __v_118: G = __loaded[25];
-        let __v_119: G = __loaded[26];
-        let __v_120: G = __loaded[27];
-        let __v_121: G = __loaded[28];
-        let __v_122: G = __loaded[29];
-        let __v_123: G = __loaded[30];
-        let __v_124: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_125: G = __loaded[0];
-        let __v_126: G = __loaded[1];
-        let __v_127: G = __loaded[2];
-        let __v_128: G = __loaded[3];
-        let __v_129: G = __loaded[4];
-        let __v_130: G = __loaded[5];
-        let __v_131: G = __loaded[6];
-        let __v_132: G = __loaded[7];
-        let __v_133: G = G::from_u64(64);
-        let __v_134: G = G::from_u64(103);
-        let __v_135: G = G::from_u64(230);
-        let __v_136: G = G::from_u64(9);
-        let __v_137: G = G::from_u64(106);
-        let __v_138: G = G::from_u64(133);
-        let __v_139: G = G::from_u64(174);
-        let __v_140: G = G::from_u64(103);
-        let __v_141: G = G::from_u64(187);
-        let __v_142: G = G::from_u64(114);
-        let __v_143: G = G::from_u64(243);
-        let __v_144: G = G::from_u64(110);
-        let __v_145: G = G::from_u64(60);
-        let __v_146: G = G::from_u64(58);
-        let __v_147: G = G::from_u64(245);
-        let __v_148: G = G::from_u64(79);
-        let __v_149: G = G::from_u64(165);
-        let __v_150: G = G::from_u64(0);
-        let __v_151: G = G::from_u64(0);
-        let __v_152: G = G::from_u64(0);
-        let __v_153: G = G::from_u64(0);
-        let __v_154: G = G::from_u64(0);
-        let __v_155: G = G::from_u64(0);
-        let __v_156: G = G::from_u64(0);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-        let __v_157: G = __r_arr[0];
-        let __v_158: G = __r_arr[1];
-        let __v_159: G = __r_arr[2];
-        let __v_160: G = __r_arr[3];
-        let __v_161: G = __r_arr[4];
-        let __v_162: G = __r_arr[5];
-        let __v_163: G = __r_arr[6];
-        let __v_164: G = __r_arr[7];
-        let __v_165: G = __r_arr[8];
-        let __v_166: G = __r_arr[9];
-        let __v_167: G = __r_arr[10];
-        let __v_168: G = __r_arr[11];
-        let __v_169: G = __r_arr[12];
-        let __v_170: G = __r_arr[13];
-        let __v_171: G = __r_arr[14];
-        let __v_172: G = __r_arr[15];
-        let __v_173: G = __r_arr[16];
-        let __v_174: G = __r_arr[17];
-        let __v_175: G = __r_arr[18];
-        let __v_176: G = __r_arr[19];
-        let __v_177: G = __r_arr[20];
-        let __v_178: G = __r_arr[21];
-        let __v_179: G = __r_arr[22];
-        let __v_180: G = __r_arr[23];
-        let __v_181: G = __r_arr[24];
-        let __v_182: G = __r_arr[25];
-        let __v_183: G = __r_arr[26];
-        let __v_184: G = __r_arr[27];
-        let __v_185: G = __r_arr[28];
-        let __v_186: G = __r_arr[29];
-        let __v_187: G = __r_arr[30];
-        let __v_188: G = __r_arr[31];
-        let __v_189: G = G::from_u64(1);
-        let __v_190: G = G::from_u64(1);
-        let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_192: G = G::from_u64(0);
-        let __v_193: G = G::from_u64(1);
-        let __v_194: G = (__v_2 + __v_193);
-        let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-        let __v_196: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_196];
-        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_70: usize = 24;
-const IN_70: usize = 24;
-const OUT_70: usize = 16;
-fn aiur_fn_70(
-  inp: [G; IN_70],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_70], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_24: G = G::from_u8(__u32_bytes[0]);
-    let __v_25: G = G::from_u8(__u32_bytes[1]);
-    let __v_26: G = G::from_u8(__u32_bytes[2]);
-    let __v_27: G = G::from_u8(__u32_bytes[3]);
-    let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = (__v_28 - __v_29);
-    let __v_31: G = G::from_u64(2);
-    let __v_32: G = (__v_28 - __v_31);
-    let __v_33: G = (__v_30 * __v_32);
-    let __v_34: G = (__v_28 * __v_33);
-    let __v_35: G = G::from_u64(0);
-    if (__v_34 != __v_35) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_36: G = if unconstrained { Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record) };
-    let __v_37: G = if unconstrained { Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record) };
-    let __v_38: G = if unconstrained { Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record) };
-    let __v_39: G = if unconstrained { Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record) };
-    let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8) | (__v_36.as_canonical_u64() << 16) | (__v_37.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_40: G = G::from_u8(__u32_bytes[0]);
-    let __v_41: G = G::from_u8(__u32_bytes[1]);
-    let __v_42: G = G::from_u8(__u32_bytes[2]);
-    let __v_43: G = G::from_u8(__u32_bytes[3]);
-    let __v_44: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_45: G = (__v_44 * __v_44);
-    if (__v_45 != __v_44) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record) };
-    let __v_46: G = __b2_out.0;
-    let __v_47: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record) };
-    let __v_48: G = __b2_out.0;
-    let __v_49: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record) };
-    let __v_50: G = __b2_out.0;
-    let __v_51: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record) };
-    let __v_52: G = __b2_out.0;
-    let __v_53: G = __b2_out.1;
-    let __v_54: G = (__v_48 + __v_51);
-    let __v_55: G = (__v_50 + __v_53);
-    let __v_56: G = (__v_52 + __v_47);
-    let __v_57: G = (__v_46 + __v_49);
-    let __u32_sum: u128 = u128::from(((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8) | (__v_26.as_canonical_u64() << 16) | (__v_27.as_canonical_u64() << 24))) + u128::from(((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8) | (__v_56.as_canonical_u64() << 16) | (__v_57.as_canonical_u64() << 24))) + u128::from(((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8) | (__v_22.as_canonical_u64() << 16) | (__v_23.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_58: G = G::from_u8(__u32_bytes[0]);
-    let __v_59: G = G::from_u8(__u32_bytes[1]);
-    let __v_60: G = G::from_u8(__u32_bytes[2]);
-    let __v_61: G = G::from_u8(__u32_bytes[3]);
-    let __v_62: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_63: G = G::from_u64(1);
-    let __v_64: G = (__v_62 - __v_63);
-    let __v_65: G = G::from_u64(2);
-    let __v_66: G = (__v_62 - __v_65);
-    let __v_67: G = (__v_64 * __v_66);
-    let __v_68: G = (__v_62 * __v_67);
-    let __v_69: G = G::from_u64(0);
-    if (__v_68 != __v_69) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_70: G = if unconstrained { Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record) };
-    let __v_71: G = if unconstrained { Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record) };
-    let __v_72: G = if unconstrained { Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record) };
-    let __v_73: G = if unconstrained { Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record) };
-    let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_71.as_canonical_u64() << 0) | (__v_72.as_canonical_u64() << 8) | (__v_73.as_canonical_u64() << 16) | (__v_70.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_74: G = G::from_u8(__u32_bytes[0]);
-    let __v_75: G = G::from_u8(__u32_bytes[1]);
-    let __v_76: G = G::from_u8(__u32_bytes[2]);
-    let __v_77: G = G::from_u8(__u32_bytes[3]);
-    let __v_78: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_74; let __vj = __v_75; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_79: G = (__v_78 * __v_78);
-    if (__v_79 != __v_78) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record) };
-    let __v_80: G = __b2_out.0;
-    let __v_81: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record) };
-    let __v_82: G = __b2_out.0;
-    let __v_83: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record) };
-    let __v_84: G = __b2_out.0;
-    let __v_85: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record) };
-    let __v_86: G = __b2_out.0;
-    let __v_87: G = __b2_out.1;
-    let __v_88: G = (__v_80 + __v_83);
-    let __v_89: G = (__v_82 + __v_85);
-    let __v_90: G = (__v_84 + __v_87);
-    let __v_91: G = (__v_86 + __v_81);
-    let __ret: [G; OUT_70] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
-    if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_71: usize = 128;
-const IN_71: usize = 128;
-const OUT_71: usize = 128;
-fn aiur_fn_71(
-  inp: [G; IN_71],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_71], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    let __v_34: G = inp[34];
-    let __v_35: G = inp[35];
-    let __v_36: G = inp[36];
-    let __v_37: G = inp[37];
-    let __v_38: G = inp[38];
-    let __v_39: G = inp[39];
-    let __v_40: G = inp[40];
-    let __v_41: G = inp[41];
-    let __v_42: G = inp[42];
-    let __v_43: G = inp[43];
-    let __v_44: G = inp[44];
-    let __v_45: G = inp[45];
-    let __v_46: G = inp[46];
-    let __v_47: G = inp[47];
-    let __v_48: G = inp[48];
-    let __v_49: G = inp[49];
-    let __v_50: G = inp[50];
-    let __v_51: G = inp[51];
-    let __v_52: G = inp[52];
-    let __v_53: G = inp[53];
-    let __v_54: G = inp[54];
-    let __v_55: G = inp[55];
-    let __v_56: G = inp[56];
-    let __v_57: G = inp[57];
-    let __v_58: G = inp[58];
-    let __v_59: G = inp[59];
-    let __v_60: G = inp[60];
-    let __v_61: G = inp[61];
-    let __v_62: G = inp[62];
-    let __v_63: G = inp[63];
-    let __v_64: G = inp[64];
-    let __v_65: G = inp[65];
-    let __v_66: G = inp[66];
-    let __v_67: G = inp[67];
-    let __v_68: G = inp[68];
-    let __v_69: G = inp[69];
-    let __v_70: G = inp[70];
-    let __v_71: G = inp[71];
-    let __v_72: G = inp[72];
-    let __v_73: G = inp[73];
-    let __v_74: G = inp[74];
-    let __v_75: G = inp[75];
-    let __v_76: G = inp[76];
-    let __v_77: G = inp[77];
-    let __v_78: G = inp[78];
-    let __v_79: G = inp[79];
-    let __v_80: G = inp[80];
-    let __v_81: G = inp[81];
-    let __v_82: G = inp[82];
-    let __v_83: G = inp[83];
-    let __v_84: G = inp[84];
-    let __v_85: G = inp[85];
-    let __v_86: G = inp[86];
-    let __v_87: G = inp[87];
-    let __v_88: G = inp[88];
-    let __v_89: G = inp[89];
-    let __v_90: G = inp[90];
-    let __v_91: G = inp[91];
-    let __v_92: G = inp[92];
-    let __v_93: G = inp[93];
-    let __v_94: G = inp[94];
-    let __v_95: G = inp[95];
-    let __v_96: G = inp[96];
-    let __v_97: G = inp[97];
-    let __v_98: G = inp[98];
-    let __v_99: G = inp[99];
-    let __v_100: G = inp[100];
-    let __v_101: G = inp[101];
-    let __v_102: G = inp[102];
-    let __v_103: G = inp[103];
-    let __v_104: G = inp[104];
-    let __v_105: G = inp[105];
-    let __v_106: G = inp[106];
-    let __v_107: G = inp[107];
-    let __v_108: G = inp[108];
-    let __v_109: G = inp[109];
-    let __v_110: G = inp[110];
-    let __v_111: G = inp[111];
-    let __v_112: G = inp[112];
-    let __v_113: G = inp[113];
-    let __v_114: G = inp[114];
-    let __v_115: G = inp[115];
-    let __v_116: G = inp[116];
-    let __v_117: G = inp[117];
-    let __v_118: G = inp[118];
-    let __v_119: G = inp[119];
-    let __v_120: G = inp[120];
-    let __v_121: G = inp[121];
-    let __v_122: G = inp[122];
-    let __v_123: G = inp[123];
-    let __v_124: G = inp[124];
-    let __v_125: G = inp[125];
-    let __v_126: G = inp[126];
-    let __v_127: G = inp[127];
-    let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))) + u128::from(((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8) | (__v_66.as_canonical_u64() << 16) | (__v_67.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_128: G = G::from_u8(__u32_bytes[0]);
-    let __v_129: G = G::from_u8(__u32_bytes[1]);
-    let __v_130: G = G::from_u8(__u32_bytes[2]);
-    let __v_131: G = G::from_u8(__u32_bytes[3]);
-    let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_133: G = G::from_u64(1);
-    let __v_134: G = (__v_132 - __v_133);
-    let __v_135: G = G::from_u64(2);
-    let __v_136: G = (__v_132 - __v_135);
-    let __v_137: G = (__v_134 * __v_136);
-    let __v_138: G = (__v_132 * __v_137);
-    let __v_139: G = G::from_u64(0);
-    if (__v_138 != __v_139) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_140: G = if unconstrained { Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record) };
-    let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) };
-    let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) };
-    let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) };
-    let __u32_sum: u128 = u128::from(((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8) | (__v_34.as_canonical_u64() << 16) | (__v_35.as_canonical_u64() << 24))) + u128::from(((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8) | (__v_140.as_canonical_u64() << 16) | (__v_141.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_144: G = G::from_u8(__u32_bytes[0]);
-    let __v_145: G = G::from_u8(__u32_bytes[1]);
-    let __v_146: G = G::from_u8(__u32_bytes[2]);
-    let __v_147: G = G::from_u8(__u32_bytes[3]);
-    let __v_148: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_149: G = (__v_148 * __v_148);
-    if (__v_149 != __v_148) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record) };
-    let __v_150: G = __b2_out.0;
-    let __v_151: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) };
-    let __v_152: G = __b2_out.0;
-    let __v_153: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) };
-    let __v_154: G = __b2_out.0;
-    let __v_155: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) };
-    let __v_156: G = __b2_out.0;
-    let __v_157: G = __b2_out.1;
-    let __v_158: G = (__v_152 + __v_155);
-    let __v_159: G = (__v_154 + __v_157);
-    let __v_160: G = (__v_156 + __v_151);
-    let __v_161: G = (__v_150 + __v_153);
-    let __u32_sum: u128 = u128::from(((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8) | (__v_130.as_canonical_u64() << 16) | (__v_131.as_canonical_u64() << 24))) + u128::from(((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8) | (__v_160.as_canonical_u64() << 16) | (__v_161.as_canonical_u64() << 24))) + u128::from(((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8) | (__v_70.as_canonical_u64() << 16) | (__v_71.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_162: G = G::from_u8(__u32_bytes[0]);
-    let __v_163: G = G::from_u8(__u32_bytes[1]);
-    let __v_164: G = G::from_u8(__u32_bytes[2]);
-    let __v_165: G = G::from_u8(__u32_bytes[3]);
-    let __v_166: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_167: G = G::from_u64(1);
-    let __v_168: G = (__v_166 - __v_167);
-    let __v_169: G = G::from_u64(2);
-    let __v_170: G = (__v_166 - __v_169);
-    let __v_171: G = (__v_168 * __v_170);
-    let __v_172: G = (__v_166 * __v_171);
-    let __v_173: G = G::from_u64(0);
-    if (__v_172 != __v_173) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_174: G = if unconstrained { Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record) };
-    let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) };
-    let __v_176: G = if unconstrained { Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record) };
-    let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) };
-    let __u32_sum: u128 = u128::from(((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8) | (__v_146.as_canonical_u64() << 16) | (__v_147.as_canonical_u64() << 24))) + u128::from(((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8) | (__v_177.as_canonical_u64() << 16) | (__v_174.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_178: G = G::from_u8(__u32_bytes[0]);
-    let __v_179: G = G::from_u8(__u32_bytes[1]);
-    let __v_180: G = G::from_u8(__u32_bytes[2]);
-    let __v_181: G = G::from_u8(__u32_bytes[3]);
-    let __v_182: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_180; let __vj = __v_181; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_183: G = (__v_182 * __v_182);
-    if (__v_183 != __v_182) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record) };
-    let __v_184: G = __b2_out.0;
-    let __v_185: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) };
-    let __v_186: G = __b2_out.0;
-    let __v_187: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) };
-    let __v_188: G = __b2_out.0;
-    let __v_189: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) };
-    let __v_190: G = __b2_out.0;
-    let __v_191: G = __b2_out.1;
-    let __v_192: G = (__v_184 + __v_187);
-    let __v_193: G = (__v_186 + __v_189);
-    let __v_194: G = (__v_188 + __v_191);
-    let __v_195: G = (__v_190 + __v_185);
-    let __u32_sum: u128 = u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8) | (__v_22.as_canonical_u64() << 16) | (__v_23.as_canonical_u64() << 24))) + u128::from(((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8) | (__v_74.as_canonical_u64() << 16) | (__v_75.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_196: G = G::from_u8(__u32_bytes[0]);
-    let __v_197: G = G::from_u8(__u32_bytes[1]);
-    let __v_198: G = G::from_u8(__u32_bytes[2]);
-    let __v_199: G = G::from_u8(__u32_bytes[3]);
-    let __v_200: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_201: G = G::from_u64(1);
-    let __v_202: G = (__v_200 - __v_201);
-    let __v_203: G = G::from_u64(2);
-    let __v_204: G = (__v_200 - __v_203);
-    let __v_205: G = (__v_202 * __v_204);
-    let __v_206: G = (__v_200 * __v_205);
-    let __v_207: G = G::from_u64(0);
-    if (__v_206 != __v_207) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_207.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_208: G = if unconstrained { Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record) };
-    let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) };
-    let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) };
-    let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) };
-    let __u32_sum: u128 = u128::from(((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8) | (__v_38.as_canonical_u64() << 16) | (__v_39.as_canonical_u64() << 24))) + u128::from(((__v_210.as_canonical_u64() << 0) | (__v_211.as_canonical_u64() << 8) | (__v_208.as_canonical_u64() << 16) | (__v_209.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_212: G = G::from_u8(__u32_bytes[0]);
-    let __v_213: G = G::from_u8(__u32_bytes[1]);
-    let __v_214: G = G::from_u8(__u32_bytes[2]);
-    let __v_215: G = G::from_u8(__u32_bytes[3]);
-    let __v_216: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_212; let __vj = __v_213; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_214; let __vj = __v_215; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_217: G = (__v_216 * __v_216);
-    if (__v_217 != __v_216) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_216.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record) };
-    let __v_218: G = __b2_out.0;
-    let __v_219: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) };
-    let __v_220: G = __b2_out.0;
-    let __v_221: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) };
-    let __v_222: G = __b2_out.0;
-    let __v_223: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) };
-    let __v_224: G = __b2_out.0;
-    let __v_225: G = __b2_out.1;
-    let __v_226: G = (__v_220 + __v_223);
-    let __v_227: G = (__v_222 + __v_225);
-    let __v_228: G = (__v_224 + __v_219);
-    let __v_229: G = (__v_218 + __v_221);
-    let __u32_sum: u128 = u128::from(((__v_196.as_canonical_u64() << 0) | (__v_197.as_canonical_u64() << 8) | (__v_198.as_canonical_u64() << 16) | (__v_199.as_canonical_u64() << 24))) + u128::from(((__v_226.as_canonical_u64() << 0) | (__v_227.as_canonical_u64() << 8) | (__v_228.as_canonical_u64() << 16) | (__v_229.as_canonical_u64() << 24))) + u128::from(((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8) | (__v_78.as_canonical_u64() << 16) | (__v_79.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_230: G = G::from_u8(__u32_bytes[0]);
-    let __v_231: G = G::from_u8(__u32_bytes[1]);
-    let __v_232: G = G::from_u8(__u32_bytes[2]);
-    let __v_233: G = G::from_u8(__u32_bytes[3]);
-    let __v_234: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_230; let __vj = __v_231; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_232; let __vj = __v_233; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_235: G = G::from_u64(1);
-    let __v_236: G = (__v_234 - __v_235);
-    let __v_237: G = G::from_u64(2);
-    let __v_238: G = (__v_234 - __v_237);
-    let __v_239: G = (__v_236 * __v_238);
-    let __v_240: G = (__v_234 * __v_239);
-    let __v_241: G = G::from_u64(0);
-    if (__v_240 != __v_241) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_242: G = if unconstrained { Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record) };
-    let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) };
-    let __v_244: G = if unconstrained { Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record) };
-    let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) };
-    let __u32_sum: u128 = u128::from(((__v_212.as_canonical_u64() << 0) | (__v_213.as_canonical_u64() << 8) | (__v_214.as_canonical_u64() << 16) | (__v_215.as_canonical_u64() << 24))) + u128::from(((__v_243.as_canonical_u64() << 0) | (__v_244.as_canonical_u64() << 8) | (__v_245.as_canonical_u64() << 16) | (__v_242.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_246: G = G::from_u8(__u32_bytes[0]);
-    let __v_247: G = G::from_u8(__u32_bytes[1]);
-    let __v_248: G = G::from_u8(__u32_bytes[2]);
-    let __v_249: G = G::from_u8(__u32_bytes[3]);
-    let __v_250: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_246; let __vj = __v_247; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_248; let __vj = __v_249; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_251: G = (__v_250 * __v_250);
-    if (__v_251 != __v_250) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_250.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record) };
-    let __v_252: G = __b2_out.0;
-    let __v_253: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) };
-    let __v_254: G = __b2_out.0;
-    let __v_255: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) };
-    let __v_256: G = __b2_out.0;
-    let __v_257: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) };
-    let __v_258: G = __b2_out.0;
-    let __v_259: G = __b2_out.1;
-    let __v_260: G = (__v_252 + __v_255);
-    let __v_261: G = (__v_254 + __v_257);
-    let __v_262: G = (__v_256 + __v_259);
-    let __v_263: G = (__v_258 + __v_253);
-    let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8) | (__v_26.as_canonical_u64() << 16) | (__v_27.as_canonical_u64() << 24))) + u128::from(((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8) | (__v_82.as_canonical_u64() << 16) | (__v_83.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_264: G = G::from_u8(__u32_bytes[0]);
-    let __v_265: G = G::from_u8(__u32_bytes[1]);
-    let __v_266: G = G::from_u8(__u32_bytes[2]);
-    let __v_267: G = G::from_u8(__u32_bytes[3]);
-    let __v_268: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_264; let __vj = __v_265; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_266; let __vj = __v_267; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_269: G = G::from_u64(1);
-    let __v_270: G = (__v_268 - __v_269);
-    let __v_271: G = G::from_u64(2);
-    let __v_272: G = (__v_268 - __v_271);
-    let __v_273: G = (__v_270 * __v_272);
-    let __v_274: G = (__v_268 * __v_273);
-    let __v_275: G = G::from_u64(0);
-    if (__v_274 != __v_275) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_275.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_276: G = if unconstrained { Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record) };
-    let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) };
-    let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) };
-    let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) };
-    let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_278.as_canonical_u64() << 0) | (__v_279.as_canonical_u64() << 8) | (__v_276.as_canonical_u64() << 16) | (__v_277.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_280: G = G::from_u8(__u32_bytes[0]);
-    let __v_281: G = G::from_u8(__u32_bytes[1]);
-    let __v_282: G = G::from_u8(__u32_bytes[2]);
-    let __v_283: G = G::from_u8(__u32_bytes[3]);
-    let __v_284: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_280; let __vj = __v_281; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_282; let __vj = __v_283; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_285: G = (__v_284 * __v_284);
-    if (__v_285 != __v_284) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_284.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record) };
-    let __v_286: G = __b2_out.0;
-    let __v_287: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) };
-    let __v_288: G = __b2_out.0;
-    let __v_289: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) };
-    let __v_290: G = __b2_out.0;
-    let __v_291: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) };
-    let __v_292: G = __b2_out.0;
-    let __v_293: G = __b2_out.1;
-    let __v_294: G = (__v_288 + __v_291);
-    let __v_295: G = (__v_290 + __v_293);
-    let __v_296: G = (__v_292 + __v_287);
-    let __v_297: G = (__v_286 + __v_289);
-    let __u32_sum: u128 = u128::from(((__v_264.as_canonical_u64() << 0) | (__v_265.as_canonical_u64() << 8) | (__v_266.as_canonical_u64() << 16) | (__v_267.as_canonical_u64() << 24))) + u128::from(((__v_294.as_canonical_u64() << 0) | (__v_295.as_canonical_u64() << 8) | (__v_296.as_canonical_u64() << 16) | (__v_297.as_canonical_u64() << 24))) + u128::from(((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8) | (__v_86.as_canonical_u64() << 16) | (__v_87.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_298: G = G::from_u8(__u32_bytes[0]);
-    let __v_299: G = G::from_u8(__u32_bytes[1]);
-    let __v_300: G = G::from_u8(__u32_bytes[2]);
-    let __v_301: G = G::from_u8(__u32_bytes[3]);
-    let __v_302: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_298; let __vj = __v_299; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_303: G = G::from_u64(1);
-    let __v_304: G = (__v_302 - __v_303);
-    let __v_305: G = G::from_u64(2);
-    let __v_306: G = (__v_302 - __v_305);
-    let __v_307: G = (__v_304 * __v_306);
-    let __v_308: G = (__v_302 * __v_307);
-    let __v_309: G = G::from_u64(0);
-    if (__v_308 != __v_309) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_310: G = if unconstrained { Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record) };
-    let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) };
-    let __v_312: G = if unconstrained { Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record) };
-    let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) };
-    let __u32_sum: u128 = u128::from(((__v_280.as_canonical_u64() << 0) | (__v_281.as_canonical_u64() << 8) | (__v_282.as_canonical_u64() << 16) | (__v_283.as_canonical_u64() << 24))) + u128::from(((__v_311.as_canonical_u64() << 0) | (__v_312.as_canonical_u64() << 8) | (__v_313.as_canonical_u64() << 16) | (__v_310.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_314: G = G::from_u8(__u32_bytes[0]);
-    let __v_315: G = G::from_u8(__u32_bytes[1]);
-    let __v_316: G = G::from_u8(__u32_bytes[2]);
-    let __v_317: G = G::from_u8(__u32_bytes[3]);
-    let __v_318: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_314; let __vj = __v_315; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_316; let __vj = __v_317; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_319: G = (__v_318 * __v_318);
-    if (__v_319 != __v_318) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_319.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record) };
-    let __v_320: G = __b2_out.0;
-    let __v_321: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) };
-    let __v_322: G = __b2_out.0;
-    let __v_323: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) };
-    let __v_324: G = __b2_out.0;
-    let __v_325: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) };
-    let __v_326: G = __b2_out.0;
-    let __v_327: G = __b2_out.1;
-    let __v_328: G = (__v_320 + __v_323);
-    let __v_329: G = (__v_322 + __v_325);
-    let __v_330: G = (__v_324 + __v_327);
-    let __v_331: G = (__v_326 + __v_321);
-    let __u32_sum: u128 = u128::from(((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8) | (__v_14.as_canonical_u64() << 16) | (__v_15.as_canonical_u64() << 24))) + u128::from(((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8) | (__v_30.as_canonical_u64() << 16) | (__v_31.as_canonical_u64() << 24))) + u128::from(((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8) | (__v_90.as_canonical_u64() << 16) | (__v_91.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_332: G = G::from_u8(__u32_bytes[0]);
-    let __v_333: G = G::from_u8(__u32_bytes[1]);
-    let __v_334: G = G::from_u8(__u32_bytes[2]);
-    let __v_335: G = G::from_u8(__u32_bytes[3]);
-    let __v_336: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_334; let __vj = __v_335; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_337: G = G::from_u64(1);
-    let __v_338: G = (__v_336 - __v_337);
-    let __v_339: G = G::from_u64(2);
-    let __v_340: G = (__v_336 - __v_339);
-    let __v_341: G = (__v_338 * __v_340);
-    let __v_342: G = (__v_336 * __v_341);
-    let __v_343: G = G::from_u64(0);
-    if (__v_342 != __v_343) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_342.as_canonical_u64(), rhs: __v_343.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_344: G = if unconstrained { Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record) };
-    let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) };
-    let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) };
-    let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) };
-    let __u32_sum: u128 = u128::from(((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8) | (__v_46.as_canonical_u64() << 16) | (__v_47.as_canonical_u64() << 24))) + u128::from(((__v_346.as_canonical_u64() << 0) | (__v_347.as_canonical_u64() << 8) | (__v_344.as_canonical_u64() << 16) | (__v_345.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_348: G = G::from_u8(__u32_bytes[0]);
-    let __v_349: G = G::from_u8(__u32_bytes[1]);
-    let __v_350: G = G::from_u8(__u32_bytes[2]);
-    let __v_351: G = G::from_u8(__u32_bytes[3]);
-    let __v_352: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_353: G = (__v_352 * __v_352);
-    if (__v_353 != __v_352) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_353.as_canonical_u64(), rhs: __v_352.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record) };
-    let __v_354: G = __b2_out.0;
-    let __v_355: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) };
-    let __v_356: G = __b2_out.0;
-    let __v_357: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) };
-    let __v_358: G = __b2_out.0;
-    let __v_359: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) };
-    let __v_360: G = __b2_out.0;
-    let __v_361: G = __b2_out.1;
-    let __v_362: G = (__v_356 + __v_359);
-    let __v_363: G = (__v_358 + __v_361);
-    let __v_364: G = (__v_360 + __v_355);
-    let __v_365: G = (__v_354 + __v_357);
-    let __u32_sum: u128 = u128::from(((__v_332.as_canonical_u64() << 0) | (__v_333.as_canonical_u64() << 8) | (__v_334.as_canonical_u64() << 16) | (__v_335.as_canonical_u64() << 24))) + u128::from(((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8) | (__v_364.as_canonical_u64() << 16) | (__v_365.as_canonical_u64() << 24))) + u128::from(((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8) | (__v_94.as_canonical_u64() << 16) | (__v_95.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_366: G = G::from_u8(__u32_bytes[0]);
-    let __v_367: G = G::from_u8(__u32_bytes[1]);
-    let __v_368: G = G::from_u8(__u32_bytes[2]);
-    let __v_369: G = G::from_u8(__u32_bytes[3]);
-    let __v_370: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_366; let __vj = __v_367; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_368; let __vj = __v_369; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_371: G = G::from_u64(1);
-    let __v_372: G = (__v_370 - __v_371);
-    let __v_373: G = G::from_u64(2);
-    let __v_374: G = (__v_370 - __v_373);
-    let __v_375: G = (__v_372 * __v_374);
-    let __v_376: G = (__v_370 * __v_375);
-    let __v_377: G = G::from_u64(0);
-    if (__v_376 != __v_377) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_377.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_378: G = if unconstrained { Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record) };
-    let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) };
-    let __v_380: G = if unconstrained { Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record) };
-    let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) };
-    let __u32_sum: u128 = u128::from(((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8) | (__v_350.as_canonical_u64() << 16) | (__v_351.as_canonical_u64() << 24))) + u128::from(((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8) | (__v_381.as_canonical_u64() << 16) | (__v_378.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_382: G = G::from_u8(__u32_bytes[0]);
-    let __v_383: G = G::from_u8(__u32_bytes[1]);
-    let __v_384: G = G::from_u8(__u32_bytes[2]);
-    let __v_385: G = G::from_u8(__u32_bytes[3]);
-    let __v_386: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_384; let __vj = __v_385; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_387: G = (__v_386 * __v_386);
-    if (__v_387 != __v_386) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_386.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record) };
-    let __v_388: G = __b2_out.0;
-    let __v_389: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) };
-    let __v_390: G = __b2_out.0;
-    let __v_391: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) };
-    let __v_392: G = __b2_out.0;
-    let __v_393: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) };
-    let __v_394: G = __b2_out.0;
-    let __v_395: G = __b2_out.1;
-    let __v_396: G = (__v_388 + __v_391);
-    let __v_397: G = (__v_390 + __v_393);
-    let __v_398: G = (__v_392 + __v_395);
-    let __v_399: G = (__v_394 + __v_389);
-    let __u32_sum: u128 = u128::from(((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8) | (__v_164.as_canonical_u64() << 16) | (__v_165.as_canonical_u64() << 24))) + u128::from(((__v_260.as_canonical_u64() << 0) | (__v_261.as_canonical_u64() << 8) | (__v_262.as_canonical_u64() << 16) | (__v_263.as_canonical_u64() << 24))) + u128::from(((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8) | (__v_98.as_canonical_u64() << 16) | (__v_99.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_400: G = G::from_u8(__u32_bytes[0]);
-    let __v_401: G = G::from_u8(__u32_bytes[1]);
-    let __v_402: G = G::from_u8(__u32_bytes[2]);
-    let __v_403: G = G::from_u8(__u32_bytes[3]);
-    let __v_404: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_400; let __vj = __v_401; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_402; let __vj = __v_403; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_405: G = G::from_u64(1);
-    let __v_406: G = (__v_404 - __v_405);
-    let __v_407: G = G::from_u64(2);
-    let __v_408: G = (__v_404 - __v_407);
-    let __v_409: G = (__v_406 * __v_408);
-    let __v_410: G = (__v_404 * __v_409);
-    let __v_411: G = G::from_u64(0);
-    if (__v_410 != __v_411) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_410.as_canonical_u64(), rhs: __v_411.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_412: G = if unconstrained { Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record) };
-    let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) };
-    let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) };
-    let __v_415: G = if unconstrained { Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record) };
-    let __u32_sum: u128 = u128::from(((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8) | (__v_316.as_canonical_u64() << 16) | (__v_317.as_canonical_u64() << 24))) + u128::from(((__v_414.as_canonical_u64() << 0) | (__v_415.as_canonical_u64() << 8) | (__v_412.as_canonical_u64() << 16) | (__v_413.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_416: G = G::from_u8(__u32_bytes[0]);
-    let __v_417: G = G::from_u8(__u32_bytes[1]);
-    let __v_418: G = G::from_u8(__u32_bytes[2]);
-    let __v_419: G = G::from_u8(__u32_bytes[3]);
-    let __v_420: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_416; let __vj = __v_417; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_418; let __vj = __v_419; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_421: G = (__v_420 * __v_420);
-    if (__v_421 != __v_420) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_420.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record) };
-    let __v_422: G = __b2_out.0;
-    let __v_423: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) };
-    let __v_424: G = __b2_out.0;
-    let __v_425: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) };
-    let __v_426: G = __b2_out.0;
-    let __v_427: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) };
-    let __v_428: G = __b2_out.0;
-    let __v_429: G = __b2_out.1;
-    let __v_430: G = (__v_424 + __v_427);
-    let __v_431: G = (__v_426 + __v_429);
-    let __v_432: G = (__v_428 + __v_423);
-    let __v_433: G = (__v_422 + __v_425);
-    let __u32_sum: u128 = u128::from(((__v_400.as_canonical_u64() << 0) | (__v_401.as_canonical_u64() << 8) | (__v_402.as_canonical_u64() << 16) | (__v_403.as_canonical_u64() << 24))) + u128::from(((__v_430.as_canonical_u64() << 0) | (__v_431.as_canonical_u64() << 8) | (__v_432.as_canonical_u64() << 16) | (__v_433.as_canonical_u64() << 24))) + u128::from(((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8) | (__v_102.as_canonical_u64() << 16) | (__v_103.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_434: G = G::from_u8(__u32_bytes[0]);
-    let __v_435: G = G::from_u8(__u32_bytes[1]);
-    let __v_436: G = G::from_u8(__u32_bytes[2]);
-    let __v_437: G = G::from_u8(__u32_bytes[3]);
-    let __v_438: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_434; let __vj = __v_435; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_436; let __vj = __v_437; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_439: G = G::from_u64(1);
-    let __v_440: G = (__v_438 - __v_439);
-    let __v_441: G = G::from_u64(2);
-    let __v_442: G = (__v_438 - __v_441);
-    let __v_443: G = (__v_440 * __v_442);
-    let __v_444: G = (__v_438 * __v_443);
-    let __v_445: G = G::from_u64(0);
-    if (__v_444 != __v_445) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_445.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_446: G = if unconstrained { Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record) };
-    let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) };
-    let __v_448: G = if unconstrained { Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record) };
-    let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) };
-    let __u32_sum: u128 = u128::from(((__v_416.as_canonical_u64() << 0) | (__v_417.as_canonical_u64() << 8) | (__v_418.as_canonical_u64() << 16) | (__v_419.as_canonical_u64() << 24))) + u128::from(((__v_447.as_canonical_u64() << 0) | (__v_448.as_canonical_u64() << 8) | (__v_449.as_canonical_u64() << 16) | (__v_446.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_450: G = G::from_u8(__u32_bytes[0]);
-    let __v_451: G = G::from_u8(__u32_bytes[1]);
-    let __v_452: G = G::from_u8(__u32_bytes[2]);
-    let __v_453: G = G::from_u8(__u32_bytes[3]);
-    let __v_454: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_450; let __vj = __v_451; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_452; let __vj = __v_453; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_455: G = (__v_454 * __v_454);
-    if (__v_455 != __v_454) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record) };
-    let __v_456: G = __b2_out.0;
-    let __v_457: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) };
-    let __v_458: G = __b2_out.0;
-    let __v_459: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) };
-    let __v_460: G = __b2_out.0;
-    let __v_461: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) };
-    let __v_462: G = __b2_out.0;
-    let __v_463: G = __b2_out.1;
-    let __v_464: G = (__v_456 + __v_459);
-    let __v_465: G = (__v_458 + __v_461);
-    let __v_466: G = (__v_460 + __v_463);
-    let __v_467: G = (__v_462 + __v_457);
-    let __u32_sum: u128 = u128::from(((__v_230.as_canonical_u64() << 0) | (__v_231.as_canonical_u64() << 8) | (__v_232.as_canonical_u64() << 16) | (__v_233.as_canonical_u64() << 24))) + u128::from(((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8) | (__v_330.as_canonical_u64() << 16) | (__v_331.as_canonical_u64() << 24))) + u128::from(((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8) | (__v_106.as_canonical_u64() << 16) | (__v_107.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_468: G = G::from_u8(__u32_bytes[0]);
-    let __v_469: G = G::from_u8(__u32_bytes[1]);
-    let __v_470: G = G::from_u8(__u32_bytes[2]);
-    let __v_471: G = G::from_u8(__u32_bytes[3]);
-    let __v_472: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_468; let __vj = __v_469; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_470; let __vj = __v_471; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_473: G = G::from_u64(1);
-    let __v_474: G = (__v_472 - __v_473);
-    let __v_475: G = G::from_u64(2);
-    let __v_476: G = (__v_472 - __v_475);
-    let __v_477: G = (__v_474 * __v_476);
-    let __v_478: G = (__v_472 * __v_477);
-    let __v_479: G = G::from_u64(0);
-    if (__v_478 != __v_479) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_480: G = if unconstrained { Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record) };
-    let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) };
-    let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) };
-    let __v_483: G = if unconstrained { Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record) };
-    let __u32_sum: u128 = u128::from(((__v_382.as_canonical_u64() << 0) | (__v_383.as_canonical_u64() << 8) | (__v_384.as_canonical_u64() << 16) | (__v_385.as_canonical_u64() << 24))) + u128::from(((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8) | (__v_480.as_canonical_u64() << 16) | (__v_481.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_484: G = G::from_u8(__u32_bytes[0]);
-    let __v_485: G = G::from_u8(__u32_bytes[1]);
-    let __v_486: G = G::from_u8(__u32_bytes[2]);
-    let __v_487: G = G::from_u8(__u32_bytes[3]);
-    let __v_488: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_484; let __vj = __v_485; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_489: G = (__v_488 * __v_488);
-    if (__v_489 != __v_488) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record) };
-    let __v_490: G = __b2_out.0;
-    let __v_491: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) };
-    let __v_492: G = __b2_out.0;
-    let __v_493: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) };
-    let __v_494: G = __b2_out.0;
-    let __v_495: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) };
-    let __v_496: G = __b2_out.0;
-    let __v_497: G = __b2_out.1;
-    let __v_498: G = (__v_492 + __v_495);
-    let __v_499: G = (__v_494 + __v_497);
-    let __v_500: G = (__v_496 + __v_491);
-    let __v_501: G = (__v_490 + __v_493);
-    let __u32_sum: u128 = u128::from(((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8) | (__v_470.as_canonical_u64() << 16) | (__v_471.as_canonical_u64() << 24))) + u128::from(((__v_498.as_canonical_u64() << 0) | (__v_499.as_canonical_u64() << 8) | (__v_500.as_canonical_u64() << 16) | (__v_501.as_canonical_u64() << 24))) + u128::from(((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8) | (__v_110.as_canonical_u64() << 16) | (__v_111.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_502: G = G::from_u8(__u32_bytes[0]);
-    let __v_503: G = G::from_u8(__u32_bytes[1]);
-    let __v_504: G = G::from_u8(__u32_bytes[2]);
-    let __v_505: G = G::from_u8(__u32_bytes[3]);
-    let __v_506: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_502; let __vj = __v_503; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_507: G = G::from_u64(1);
-    let __v_508: G = (__v_506 - __v_507);
-    let __v_509: G = G::from_u64(2);
-    let __v_510: G = (__v_506 - __v_509);
-    let __v_511: G = (__v_508 * __v_510);
-    let __v_512: G = (__v_506 * __v_511);
-    let __v_513: G = G::from_u64(0);
-    if (__v_512 != __v_513) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_514: G = if unconstrained { Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record) };
-    let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) };
-    let __v_516: G = if unconstrained { Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record) };
-    let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) };
-    let __u32_sum: u128 = u128::from(((__v_484.as_canonical_u64() << 0) | (__v_485.as_canonical_u64() << 8) | (__v_486.as_canonical_u64() << 16) | (__v_487.as_canonical_u64() << 24))) + u128::from(((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8) | (__v_517.as_canonical_u64() << 16) | (__v_514.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_518: G = G::from_u8(__u32_bytes[0]);
-    let __v_519: G = G::from_u8(__u32_bytes[1]);
-    let __v_520: G = G::from_u8(__u32_bytes[2]);
-    let __v_521: G = G::from_u8(__u32_bytes[3]);
-    let __v_522: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_520; let __vj = __v_521; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_523: G = (__v_522 * __v_522);
-    if (__v_523 != __v_522) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_522.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record) };
-    let __v_524: G = __b2_out.0;
-    let __v_525: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) };
-    let __v_526: G = __b2_out.0;
-    let __v_527: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) };
-    let __v_528: G = __b2_out.0;
-    let __v_529: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) };
-    let __v_530: G = __b2_out.0;
-    let __v_531: G = __b2_out.1;
-    let __v_532: G = (__v_524 + __v_527);
-    let __v_533: G = (__v_526 + __v_529);
-    let __v_534: G = (__v_528 + __v_531);
-    let __v_535: G = (__v_530 + __v_525);
-    let __u32_sum: u128 = u128::from(((__v_298.as_canonical_u64() << 0) | (__v_299.as_canonical_u64() << 8) | (__v_300.as_canonical_u64() << 16) | (__v_301.as_canonical_u64() << 24))) + u128::from(((__v_396.as_canonical_u64() << 0) | (__v_397.as_canonical_u64() << 8) | (__v_398.as_canonical_u64() << 16) | (__v_399.as_canonical_u64() << 24))) + u128::from(((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8) | (__v_114.as_canonical_u64() << 16) | (__v_115.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_536: G = G::from_u8(__u32_bytes[0]);
-    let __v_537: G = G::from_u8(__u32_bytes[1]);
-    let __v_538: G = G::from_u8(__u32_bytes[2]);
-    let __v_539: G = G::from_u8(__u32_bytes[3]);
-    let __v_540: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_538; let __vj = __v_539; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_541: G = G::from_u64(1);
-    let __v_542: G = (__v_540 - __v_541);
-    let __v_543: G = G::from_u64(2);
-    let __v_544: G = (__v_540 - __v_543);
-    let __v_545: G = (__v_542 * __v_544);
-    let __v_546: G = (__v_540 * __v_545);
-    let __v_547: G = G::from_u64(0);
-    if (__v_546 != __v_547) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_546.as_canonical_u64(), rhs: __v_547.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_548: G = if unconstrained { Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record) };
-    let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) };
-    let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) };
-    let __v_551: G = if unconstrained { Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record) };
-    let __u32_sum: u128 = u128::from(((__v_178.as_canonical_u64() << 0) | (__v_179.as_canonical_u64() << 8) | (__v_180.as_canonical_u64() << 16) | (__v_181.as_canonical_u64() << 24))) + u128::from(((__v_550.as_canonical_u64() << 0) | (__v_551.as_canonical_u64() << 8) | (__v_548.as_canonical_u64() << 16) | (__v_549.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_552: G = G::from_u8(__u32_bytes[0]);
-    let __v_553: G = G::from_u8(__u32_bytes[1]);
-    let __v_554: G = G::from_u8(__u32_bytes[2]);
-    let __v_555: G = G::from_u8(__u32_bytes[3]);
-    let __v_556: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_552; let __vj = __v_553; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_554; let __vj = __v_555; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_557: G = (__v_556 * __v_556);
-    if (__v_557 != __v_556) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_557.as_canonical_u64(), rhs: __v_556.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record) };
-    let __v_558: G = __b2_out.0;
-    let __v_559: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) };
-    let __v_560: G = __b2_out.0;
-    let __v_561: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) };
-    let __v_562: G = __b2_out.0;
-    let __v_563: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) };
-    let __v_564: G = __b2_out.0;
-    let __v_565: G = __b2_out.1;
-    let __v_566: G = (__v_560 + __v_563);
-    let __v_567: G = (__v_562 + __v_565);
-    let __v_568: G = (__v_564 + __v_559);
-    let __v_569: G = (__v_558 + __v_561);
-    let __u32_sum: u128 = u128::from(((__v_536.as_canonical_u64() << 0) | (__v_537.as_canonical_u64() << 8) | (__v_538.as_canonical_u64() << 16) | (__v_539.as_canonical_u64() << 24))) + u128::from(((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8) | (__v_568.as_canonical_u64() << 16) | (__v_569.as_canonical_u64() << 24))) + u128::from(((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8) | (__v_118.as_canonical_u64() << 16) | (__v_119.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_570: G = G::from_u8(__u32_bytes[0]);
-    let __v_571: G = G::from_u8(__u32_bytes[1]);
-    let __v_572: G = G::from_u8(__u32_bytes[2]);
-    let __v_573: G = G::from_u8(__u32_bytes[3]);
-    let __v_574: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_570; let __vj = __v_571; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_572; let __vj = __v_573; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_575: G = G::from_u64(1);
-    let __v_576: G = (__v_574 - __v_575);
-    let __v_577: G = G::from_u64(2);
-    let __v_578: G = (__v_574 - __v_577);
-    let __v_579: G = (__v_576 * __v_578);
-    let __v_580: G = (__v_574 * __v_579);
-    let __v_581: G = G::from_u64(0);
-    if (__v_580 != __v_581) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_580.as_canonical_u64(), rhs: __v_581.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_582: G = if unconstrained { Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record) };
-    let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) };
-    let __v_584: G = if unconstrained { Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record) };
-    let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) };
-    let __u32_sum: u128 = u128::from(((__v_552.as_canonical_u64() << 0) | (__v_553.as_canonical_u64() << 8) | (__v_554.as_canonical_u64() << 16) | (__v_555.as_canonical_u64() << 24))) + u128::from(((__v_583.as_canonical_u64() << 0) | (__v_584.as_canonical_u64() << 8) | (__v_585.as_canonical_u64() << 16) | (__v_582.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_586: G = G::from_u8(__u32_bytes[0]);
-    let __v_587: G = G::from_u8(__u32_bytes[1]);
-    let __v_588: G = G::from_u8(__u32_bytes[2]);
-    let __v_589: G = G::from_u8(__u32_bytes[3]);
-    let __v_590: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_586; let __vj = __v_587; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_588; let __vj = __v_589; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_591: G = (__v_590 * __v_590);
-    if (__v_591 != __v_590) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_590.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record) };
-    let __v_592: G = __b2_out.0;
-    let __v_593: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) };
-    let __v_594: G = __b2_out.0;
-    let __v_595: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) };
-    let __v_596: G = __b2_out.0;
-    let __v_597: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) };
-    let __v_598: G = __b2_out.0;
-    let __v_599: G = __b2_out.1;
-    let __v_600: G = (__v_592 + __v_595);
-    let __v_601: G = (__v_594 + __v_597);
-    let __v_602: G = (__v_596 + __v_599);
-    let __v_603: G = (__v_598 + __v_593);
-    let __u32_sum: u128 = u128::from(((__v_366.as_canonical_u64() << 0) | (__v_367.as_canonical_u64() << 8) | (__v_368.as_canonical_u64() << 16) | (__v_369.as_canonical_u64() << 24))) + u128::from(((__v_192.as_canonical_u64() << 0) | (__v_193.as_canonical_u64() << 8) | (__v_194.as_canonical_u64() << 16) | (__v_195.as_canonical_u64() << 24))) + u128::from(((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8) | (__v_122.as_canonical_u64() << 16) | (__v_123.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_604: G = G::from_u8(__u32_bytes[0]);
-    let __v_605: G = G::from_u8(__u32_bytes[1]);
-    let __v_606: G = G::from_u8(__u32_bytes[2]);
-    let __v_607: G = G::from_u8(__u32_bytes[3]);
-    let __v_608: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_604; let __vj = __v_605; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_606; let __vj = __v_607; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_609: G = G::from_u64(1);
-    let __v_610: G = (__v_608 - __v_609);
-    let __v_611: G = G::from_u64(2);
-    let __v_612: G = (__v_608 - __v_611);
-    let __v_613: G = (__v_610 * __v_612);
-    let __v_614: G = (__v_608 * __v_613);
-    let __v_615: G = G::from_u64(0);
-    if (__v_614 != __v_615) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_615.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_616: G = if unconstrained { Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record) };
-    let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) };
-    let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) };
-    let __v_619: G = if unconstrained { Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record) };
-    let __u32_sum: u128 = u128::from(((__v_246.as_canonical_u64() << 0) | (__v_247.as_canonical_u64() << 8) | (__v_248.as_canonical_u64() << 16) | (__v_249.as_canonical_u64() << 24))) + u128::from(((__v_618.as_canonical_u64() << 0) | (__v_619.as_canonical_u64() << 8) | (__v_616.as_canonical_u64() << 16) | (__v_617.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_620: G = G::from_u8(__u32_bytes[0]);
-    let __v_621: G = G::from_u8(__u32_bytes[1]);
-    let __v_622: G = G::from_u8(__u32_bytes[2]);
-    let __v_623: G = G::from_u8(__u32_bytes[3]);
-    let __v_624: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_620; let __vj = __v_621; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_622; let __vj = __v_623; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_625: G = (__v_624 * __v_624);
-    if (__v_625 != __v_624) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_625.as_canonical_u64(), rhs: __v_624.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record) };
-    let __v_626: G = __b2_out.0;
-    let __v_627: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) };
-    let __v_628: G = __b2_out.0;
-    let __v_629: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) };
-    let __v_630: G = __b2_out.0;
-    let __v_631: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) };
-    let __v_632: G = __b2_out.0;
-    let __v_633: G = __b2_out.1;
-    let __v_634: G = (__v_628 + __v_631);
-    let __v_635: G = (__v_630 + __v_633);
-    let __v_636: G = (__v_632 + __v_627);
-    let __v_637: G = (__v_626 + __v_629);
-    let __u32_sum: u128 = u128::from(((__v_604.as_canonical_u64() << 0) | (__v_605.as_canonical_u64() << 8) | (__v_606.as_canonical_u64() << 16) | (__v_607.as_canonical_u64() << 24))) + u128::from(((__v_634.as_canonical_u64() << 0) | (__v_635.as_canonical_u64() << 8) | (__v_636.as_canonical_u64() << 16) | (__v_637.as_canonical_u64() << 24))) + u128::from(((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8) | (__v_126.as_canonical_u64() << 16) | (__v_127.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_638: G = G::from_u8(__u32_bytes[0]);
-    let __v_639: G = G::from_u8(__u32_bytes[1]);
-    let __v_640: G = G::from_u8(__u32_bytes[2]);
-    let __v_641: G = G::from_u8(__u32_bytes[3]);
-    let __v_642: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_638; let __vj = __v_639; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_640; let __vj = __v_641; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_643: G = G::from_u64(1);
-    let __v_644: G = (__v_642 - __v_643);
-    let __v_645: G = G::from_u64(2);
-    let __v_646: G = (__v_642 - __v_645);
-    let __v_647: G = (__v_644 * __v_646);
-    let __v_648: G = (__v_642 * __v_647);
-    let __v_649: G = G::from_u64(0);
-    if (__v_648 != __v_649) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __v_650: G = if unconstrained { Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record) };
-    let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) };
-    let __v_652: G = if unconstrained { Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record) };
-    let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) };
-    let __u32_sum: u128 = u128::from(((__v_620.as_canonical_u64() << 0) | (__v_621.as_canonical_u64() << 8) | (__v_622.as_canonical_u64() << 16) | (__v_623.as_canonical_u64() << 24))) + u128::from(((__v_651.as_canonical_u64() << 0) | (__v_652.as_canonical_u64() << 8) | (__v_653.as_canonical_u64() << 16) | (__v_650.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_654: G = G::from_u8(__u32_bytes[0]);
-    let __v_655: G = G::from_u8(__u32_bytes[1]);
-    let __v_656: G = G::from_u8(__u32_bytes[2]);
-    let __v_657: G = G::from_u8(__u32_bytes[3]);
-    let __v_658: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_654; let __vj = __v_655; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_656; let __vj = __v_657; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_659: G = (__v_658 * __v_658);
-    if (__v_659 != __v_658) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_658.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-    }
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record) };
-    let __v_660: G = __b2_out.0;
-    let __v_661: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) };
-    let __v_662: G = __b2_out.0;
-    let __v_663: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) };
-    let __v_664: G = __b2_out.0;
-    let __v_665: G = __b2_out.1;
-    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) };
-    let __v_666: G = __b2_out.0;
-    let __v_667: G = __b2_out.1;
-    let __v_668: G = (__v_660 + __v_663);
-    let __v_669: G = (__v_662 + __v_665);
-    let __v_670: G = (__v_664 + __v_667);
-    let __v_671: G = (__v_666 + __v_661);
-    let __ret: [G; OUT_71] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127];
-    if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_72: usize = 106;
-const IN_72: usize = 106;
-const OUT_72: usize = 32;
-fn aiur_fn_72(
-  inp: [G; IN_72],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_72], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    let __v_34: G = inp[34];
-    let __v_35: G = inp[35];
-    let __v_36: G = inp[36];
-    let __v_37: G = inp[37];
-    let __v_38: G = inp[38];
-    let __v_39: G = inp[39];
-    let __v_40: G = inp[40];
-    let __v_41: G = inp[41];
-    let __v_42: G = inp[42];
-    let __v_43: G = inp[43];
-    let __v_44: G = inp[44];
-    let __v_45: G = inp[45];
-    let __v_46: G = inp[46];
-    let __v_47: G = inp[47];
-    let __v_48: G = inp[48];
-    let __v_49: G = inp[49];
-    let __v_50: G = inp[50];
-    let __v_51: G = inp[51];
-    let __v_52: G = inp[52];
-    let __v_53: G = inp[53];
-    let __v_54: G = inp[54];
-    let __v_55: G = inp[55];
-    let __v_56: G = inp[56];
-    let __v_57: G = inp[57];
-    let __v_58: G = inp[58];
-    let __v_59: G = inp[59];
-    let __v_60: G = inp[60];
-    let __v_61: G = inp[61];
-    let __v_62: G = inp[62];
-    let __v_63: G = inp[63];
-    let __v_64: G = inp[64];
-    let __v_65: G = inp[65];
-    let __v_66: G = inp[66];
-    let __v_67: G = inp[67];
-    let __v_68: G = inp[68];
-    let __v_69: G = inp[69];
-    let __v_70: G = inp[70];
-    let __v_71: G = inp[71];
-    let __v_72: G = inp[72];
-    let __v_73: G = inp[73];
-    let __v_74: G = inp[74];
-    let __v_75: G = inp[75];
-    let __v_76: G = inp[76];
-    let __v_77: G = inp[77];
-    let __v_78: G = inp[78];
-    let __v_79: G = inp[79];
-    let __v_80: G = inp[80];
-    let __v_81: G = inp[81];
-    let __v_82: G = inp[82];
-    let __v_83: G = inp[83];
-    let __v_84: G = inp[84];
-    let __v_85: G = inp[85];
-    let __v_86: G = inp[86];
-    let __v_87: G = inp[87];
-    let __v_88: G = inp[88];
-    let __v_89: G = inp[89];
-    let __v_90: G = inp[90];
-    let __v_91: G = inp[91];
-    let __v_92: G = inp[92];
-    let __v_93: G = inp[93];
-    let __v_94: G = inp[94];
-    let __v_95: G = inp[95];
-    let __v_96: G = inp[96];
-    let __v_97: G = inp[97];
-    let __v_98: G = inp[98];
-    let __v_99: G = inp[99];
-    let __v_100: G = inp[100];
-    let __v_101: G = inp[101];
-    let __v_102: G = inp[102];
-    let __v_103: G = inp[103];
-    let __v_104: G = inp[104];
-    let __v_105: G = inp[105];
-    let __v_106: G = G::from_u64(103);
-    let __v_107: G = G::from_u64(230);
-    let __v_108: G = G::from_u64(9);
-    let __v_109: G = G::from_u64(106);
-    let __v_110: G = G::from_u64(133);
-    let __v_111: G = G::from_u64(174);
-    let __v_112: G = G::from_u64(103);
-    let __v_113: G = G::from_u64(187);
-    let __v_114: G = G::from_u64(114);
-    let __v_115: G = G::from_u64(243);
-    let __v_116: G = G::from_u64(110);
-    let __v_117: G = G::from_u64(60);
-    let __v_118: G = G::from_u64(58);
-    let __v_119: G = G::from_u64(245);
-    let __v_120: G = G::from_u64(79);
-    let __v_121: G = G::from_u64(165);
-    let __v_122: G = G::from_u64(0);
-    let __v_123: G = G::from_u64(0);
-    let __v_124: G = G::from_u64(0);
-    let __v_125: G = G::from_u64(0);
-    let __v_126: G = G::from_u64(0);
-    let __v_127: G = G::from_u64(0);
-    let __v_128: G = G::from_u64(0);
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-    let __v_129: G = __r_arr[0];
-    let __v_130: G = __r_arr[1];
-    let __v_131: G = __r_arr[2];
-    let __v_132: G = __r_arr[3];
-    let __v_133: G = __r_arr[4];
-    let __v_134: G = __r_arr[5];
-    let __v_135: G = __r_arr[6];
-    let __v_136: G = __r_arr[7];
-    let __v_137: G = __r_arr[8];
-    let __v_138: G = __r_arr[9];
-    let __v_139: G = __r_arr[10];
-    let __v_140: G = __r_arr[11];
-    let __v_141: G = __r_arr[12];
-    let __v_142: G = __r_arr[13];
-    let __v_143: G = __r_arr[14];
-    let __v_144: G = __r_arr[15];
-    let __v_145: G = __r_arr[16];
-    let __v_146: G = __r_arr[17];
-    let __v_147: G = __r_arr[18];
-    let __v_148: G = __r_arr[19];
-    let __v_149: G = __r_arr[20];
-    let __v_150: G = __r_arr[21];
-    let __v_151: G = __r_arr[22];
-    let __v_152: G = __r_arr[23];
-    let __v_153: G = __r_arr[24];
-    let __v_154: G = __r_arr[25];
-    let __v_155: G = __r_arr[26];
-    let __v_156: G = __r_arr[27];
-    let __v_157: G = __r_arr[28];
-    let __v_158: G = __r_arr[29];
-    let __v_159: G = __r_arr[30];
-    let __v_160: G = __r_arr[31];
-    let __ret: [G; OUT_72] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
-    if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_73: usize = 129;
-const IN_73: usize = 129;
-const OUT_73: usize = 32;
-fn aiur_fn_73(
-  inp: [G; IN_73],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_73], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    let __v_34: G = inp[34];
-    let __v_35: G = inp[35];
-    let __v_36: G = inp[36];
-    let __v_37: G = inp[37];
-    let __v_38: G = inp[38];
-    let __v_39: G = inp[39];
-    let __v_40: G = inp[40];
-    let __v_41: G = inp[41];
-    let __v_42: G = inp[42];
-    let __v_43: G = inp[43];
-    let __v_44: G = inp[44];
-    let __v_45: G = inp[45];
-    let __v_46: G = inp[46];
-    let __v_47: G = inp[47];
-    let __v_48: G = inp[48];
-    let __v_49: G = inp[49];
-    let __v_50: G = inp[50];
-    let __v_51: G = inp[51];
-    let __v_52: G = inp[52];
-    let __v_53: G = inp[53];
-    let __v_54: G = inp[54];
-    let __v_55: G = inp[55];
-    let __v_56: G = inp[56];
-    let __v_57: G = inp[57];
-    let __v_58: G = inp[58];
-    let __v_59: G = inp[59];
-    let __v_60: G = inp[60];
-    let __v_61: G = inp[61];
-    let __v_62: G = inp[62];
-    let __v_63: G = inp[63];
-    let __v_64: G = inp[64];
-    let __v_65: G = inp[65];
-    let __v_66: G = inp[66];
-    let __v_67: G = inp[67];
-    let __v_68: G = inp[68];
-    let __v_69: G = inp[69];
-    let __v_70: G = inp[70];
-    let __v_71: G = inp[71];
-    let __v_72: G = inp[72];
-    let __v_73: G = inp[73];
-    let __v_74: G = inp[74];
-    let __v_75: G = inp[75];
-    let __v_76: G = inp[76];
-    let __v_77: G = inp[77];
-    let __v_78: G = inp[78];
-    let __v_79: G = inp[79];
-    let __v_80: G = inp[80];
-    let __v_81: G = inp[81];
-    let __v_82: G = inp[82];
-    let __v_83: G = inp[83];
-    let __v_84: G = inp[84];
-    let __v_85: G = inp[85];
-    let __v_86: G = inp[86];
-    let __v_87: G = inp[87];
-    let __v_88: G = inp[88];
-    let __v_89: G = inp[89];
-    let __v_90: G = inp[90];
-    let __v_91: G = inp[91];
-    let __v_92: G = inp[92];
-    let __v_93: G = inp[93];
-    let __v_94: G = inp[94];
-    let __v_95: G = inp[95];
-    let __v_96: G = inp[96];
-    let __v_97: G = inp[97];
-    let __v_98: G = inp[98];
-    let __v_99: G = inp[99];
-    let __v_100: G = inp[100];
-    let __v_101: G = inp[101];
-    let __v_102: G = inp[102];
-    let __v_103: G = inp[103];
-    let __v_104: G = inp[104];
-    let __v_105: G = inp[105];
-    let __v_106: G = inp[106];
-    let __v_107: G = inp[107];
-    let __v_108: G = inp[108];
-    let __v_109: G = inp[109];
-    let __v_110: G = inp[110];
-    let __v_111: G = inp[111];
-    let __v_112: G = inp[112];
-    let __v_113: G = inp[113];
-    let __v_114: G = inp[114];
-    let __v_115: G = inp[115];
-    let __v_116: G = inp[116];
-    let __v_117: G = inp[117];
-    let __v_118: G = inp[118];
-    let __v_119: G = inp[119];
-    let __v_120: G = inp[120];
-    let __v_121: G = inp[121];
-    let __v_122: G = inp[122];
-    let __v_123: G = inp[123];
-    let __v_124: G = inp[124];
-    let __v_125: G = inp[125];
-    let __v_126: G = inp[126];
-    let __v_127: G = inp[127];
-    let __v_128: G = inp[128];
-    match __v_0.as_canonical_u64() {
-      7u64 => {
-        let __v_129: G = if unconstrained { Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record) };
-        let __v_130: G = if unconstrained { Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record) };
-        let __v_131: G = if unconstrained { Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record) };
-        let __v_132: G = if unconstrained { Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record) };
-        let __v_133: G = if unconstrained { Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record) };
-        let __v_134: G = if unconstrained { Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record) };
-        let __v_135: G = if unconstrained { Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record) };
-        let __v_136: G = if unconstrained { Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record) };
-        let __v_137: G = if unconstrained { Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record) };
-        let __v_138: G = if unconstrained { Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record) };
-        let __v_139: G = if unconstrained { Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record) };
-        let __v_140: G = if unconstrained { Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record) };
-        let __v_141: G = if unconstrained { Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record) };
-        let __v_142: G = if unconstrained { Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record) };
-        let __v_143: G = if unconstrained { Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record) };
-        let __v_144: G = if unconstrained { Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record) };
-        let __v_145: G = if unconstrained { Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record) };
-        let __v_146: G = if unconstrained { Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record) };
-        let __v_147: G = if unconstrained { Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record) };
-        let __v_148: G = if unconstrained { Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record) };
-        let __v_149: G = if unconstrained { Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record) };
-        let __v_150: G = if unconstrained { Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record) };
-        let __v_151: G = if unconstrained { Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record) };
-        let __v_152: G = if unconstrained { Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record) };
-        let __v_153: G = if unconstrained { Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record) };
-        let __v_154: G = if unconstrained { Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record) };
-        let __v_155: G = if unconstrained { Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record) };
-        let __v_156: G = if unconstrained { Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record) };
-        let __v_157: G = if unconstrained { Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record) };
-        let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) };
-        let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) };
-        let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) };
-        let __ret: [G; OUT_73] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
-        if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __u32_sum: u128 = u128::from(((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8) | (__v_3.as_canonical_u64() << 16) | (__v_4.as_canonical_u64() << 24))) + u128::from(((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8) | (__v_19.as_canonical_u64() << 16) | (__v_20.as_canonical_u64() << 24))) + u128::from(((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8) | (__v_67.as_canonical_u64() << 16) | (__v_68.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_129: G = G::from_u8(__u32_bytes[0]);
-        let __v_130: G = G::from_u8(__u32_bytes[1]);
-        let __v_131: G = G::from_u8(__u32_bytes[2]);
-        let __v_132: G = G::from_u8(__u32_bytes[3]);
-        let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_134: G = G::from_u64(1);
-        let __v_135: G = (__v_133 - __v_134);
-        let __v_136: G = G::from_u64(2);
-        let __v_137: G = (__v_133 - __v_136);
-        let __v_138: G = (__v_135 * __v_137);
-        let __v_139: G = (__v_133 * __v_138);
-        let __v_140: G = G::from_u64(0);
-        if (__v_139 != __v_140) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) };
-        let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) };
-        let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) };
-        let __v_144: G = if unconstrained { Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record) };
-        let __u32_sum: u128 = u128::from(((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8) | (__v_35.as_canonical_u64() << 16) | (__v_36.as_canonical_u64() << 24))) + u128::from(((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8) | (__v_141.as_canonical_u64() << 16) | (__v_142.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_145: G = G::from_u8(__u32_bytes[0]);
-        let __v_146: G = G::from_u8(__u32_bytes[1]);
-        let __v_147: G = G::from_u8(__u32_bytes[2]);
-        let __v_148: G = G::from_u8(__u32_bytes[3]);
-        let __v_149: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_150: G = (__v_149 * __v_149);
-        if (__v_150 != __v_149) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) };
-        let __v_151: G = __b2_out.0;
-        let __v_152: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) };
-        let __v_153: G = __b2_out.0;
-        let __v_154: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) };
-        let __v_155: G = __b2_out.0;
-        let __v_156: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record) };
-        let __v_157: G = __b2_out.0;
-        let __v_158: G = __b2_out.1;
-        let __v_159: G = (__v_153 + __v_156);
-        let __v_160: G = (__v_155 + __v_158);
-        let __v_161: G = (__v_157 + __v_152);
-        let __v_162: G = (__v_151 + __v_154);
-        let __u32_sum: u128 = u128::from(((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8) | (__v_131.as_canonical_u64() << 16) | (__v_132.as_canonical_u64() << 24))) + u128::from(((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8) | (__v_161.as_canonical_u64() << 16) | (__v_162.as_canonical_u64() << 24))) + u128::from(((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8) | (__v_71.as_canonical_u64() << 16) | (__v_72.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_163: G = G::from_u8(__u32_bytes[0]);
-        let __v_164: G = G::from_u8(__u32_bytes[1]);
-        let __v_165: G = G::from_u8(__u32_bytes[2]);
-        let __v_166: G = G::from_u8(__u32_bytes[3]);
-        let __v_167: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_168: G = G::from_u64(1);
-        let __v_169: G = (__v_167 - __v_168);
-        let __v_170: G = G::from_u64(2);
-        let __v_171: G = (__v_167 - __v_170);
-        let __v_172: G = (__v_169 * __v_171);
-        let __v_173: G = (__v_167 * __v_172);
-        let __v_174: G = G::from_u64(0);
-        if (__v_173 != __v_174) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_174.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) };
-        let __v_176: G = if unconstrained { Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record) };
-        let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) };
-        let __v_178: G = if unconstrained { Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record) };
-        let __u32_sum: u128 = u128::from(((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8) | (__v_147.as_canonical_u64() << 16) | (__v_148.as_canonical_u64() << 24))) + u128::from(((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8) | (__v_178.as_canonical_u64() << 16) | (__v_175.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_179: G = G::from_u8(__u32_bytes[0]);
-        let __v_180: G = G::from_u8(__u32_bytes[1]);
-        let __v_181: G = G::from_u8(__u32_bytes[2]);
-        let __v_182: G = G::from_u8(__u32_bytes[3]);
-        let __v_183: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_179; let __vj = __v_180; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_181; let __vj = __v_182; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_184: G = (__v_183 * __v_183);
-        if (__v_184 != __v_183) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) };
-        let __v_185: G = __b2_out.0;
-        let __v_186: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) };
-        let __v_187: G = __b2_out.0;
-        let __v_188: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) };
-        let __v_189: G = __b2_out.0;
-        let __v_190: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record) };
-        let __v_191: G = __b2_out.0;
-        let __v_192: G = __b2_out.1;
-        let __v_193: G = (__v_185 + __v_188);
-        let __v_194: G = (__v_187 + __v_190);
-        let __v_195: G = (__v_189 + __v_192);
-        let __v_196: G = (__v_191 + __v_186);
-        let __u32_sum: u128 = u128::from(((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8) | (__v_7.as_canonical_u64() << 16) | (__v_8.as_canonical_u64() << 24))) + u128::from(((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8) | (__v_23.as_canonical_u64() << 16) | (__v_24.as_canonical_u64() << 24))) + u128::from(((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8) | (__v_75.as_canonical_u64() << 16) | (__v_76.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_197: G = G::from_u8(__u32_bytes[0]);
-        let __v_198: G = G::from_u8(__u32_bytes[1]);
-        let __v_199: G = G::from_u8(__u32_bytes[2]);
-        let __v_200: G = G::from_u8(__u32_bytes[3]);
-        let __v_201: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_197; let __vj = __v_198; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_199; let __vj = __v_200; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_202: G = G::from_u64(1);
-        let __v_203: G = (__v_201 - __v_202);
-        let __v_204: G = G::from_u64(2);
-        let __v_205: G = (__v_201 - __v_204);
-        let __v_206: G = (__v_203 * __v_205);
-        let __v_207: G = (__v_201 * __v_206);
-        let __v_208: G = G::from_u64(0);
-        if (__v_207 != __v_208) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_208.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) };
-        let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) };
-        let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) };
-        let __v_212: G = if unconstrained { Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record) };
-        let __u32_sum: u128 = u128::from(((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8) | (__v_39.as_canonical_u64() << 16) | (__v_40.as_canonical_u64() << 24))) + u128::from(((__v_211.as_canonical_u64() << 0) | (__v_212.as_canonical_u64() << 8) | (__v_209.as_canonical_u64() << 16) | (__v_210.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_213: G = G::from_u8(__u32_bytes[0]);
-        let __v_214: G = G::from_u8(__u32_bytes[1]);
-        let __v_215: G = G::from_u8(__u32_bytes[2]);
-        let __v_216: G = G::from_u8(__u32_bytes[3]);
-        let __v_217: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_213; let __vj = __v_214; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_215; let __vj = __v_216; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_218: G = (__v_217 * __v_217);
-        if (__v_218 != __v_217) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_217.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) };
-        let __v_219: G = __b2_out.0;
-        let __v_220: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) };
-        let __v_221: G = __b2_out.0;
-        let __v_222: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) };
-        let __v_223: G = __b2_out.0;
-        let __v_224: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record) };
-        let __v_225: G = __b2_out.0;
-        let __v_226: G = __b2_out.1;
-        let __v_227: G = (__v_221 + __v_224);
-        let __v_228: G = (__v_223 + __v_226);
-        let __v_229: G = (__v_225 + __v_220);
-        let __v_230: G = (__v_219 + __v_222);
-        let __u32_sum: u128 = u128::from(((__v_197.as_canonical_u64() << 0) | (__v_198.as_canonical_u64() << 8) | (__v_199.as_canonical_u64() << 16) | (__v_200.as_canonical_u64() << 24))) + u128::from(((__v_227.as_canonical_u64() << 0) | (__v_228.as_canonical_u64() << 8) | (__v_229.as_canonical_u64() << 16) | (__v_230.as_canonical_u64() << 24))) + u128::from(((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8) | (__v_79.as_canonical_u64() << 16) | (__v_80.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_231: G = G::from_u8(__u32_bytes[0]);
-        let __v_232: G = G::from_u8(__u32_bytes[1]);
-        let __v_233: G = G::from_u8(__u32_bytes[2]);
-        let __v_234: G = G::from_u8(__u32_bytes[3]);
-        let __v_235: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_236: G = G::from_u64(1);
-        let __v_237: G = (__v_235 - __v_236);
-        let __v_238: G = G::from_u64(2);
-        let __v_239: G = (__v_235 - __v_238);
-        let __v_240: G = (__v_237 * __v_239);
-        let __v_241: G = (__v_235 * __v_240);
-        let __v_242: G = G::from_u64(0);
-        if (__v_241 != __v_242) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) };
-        let __v_244: G = if unconstrained { Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record) };
-        let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) };
-        let __v_246: G = if unconstrained { Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record) };
-        let __u32_sum: u128 = u128::from(((__v_213.as_canonical_u64() << 0) | (__v_214.as_canonical_u64() << 8) | (__v_215.as_canonical_u64() << 16) | (__v_216.as_canonical_u64() << 24))) + u128::from(((__v_244.as_canonical_u64() << 0) | (__v_245.as_canonical_u64() << 8) | (__v_246.as_canonical_u64() << 16) | (__v_243.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_247: G = G::from_u8(__u32_bytes[0]);
-        let __v_248: G = G::from_u8(__u32_bytes[1]);
-        let __v_249: G = G::from_u8(__u32_bytes[2]);
-        let __v_250: G = G::from_u8(__u32_bytes[3]);
-        let __v_251: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_247; let __vj = __v_248; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_249; let __vj = __v_250; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_252: G = (__v_251 * __v_251);
-        if (__v_252 != __v_251) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_251.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) };
-        let __v_253: G = __b2_out.0;
-        let __v_254: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) };
-        let __v_255: G = __b2_out.0;
-        let __v_256: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) };
-        let __v_257: G = __b2_out.0;
-        let __v_258: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record) };
-        let __v_259: G = __b2_out.0;
-        let __v_260: G = __b2_out.1;
-        let __v_261: G = (__v_253 + __v_256);
-        let __v_262: G = (__v_255 + __v_258);
-        let __v_263: G = (__v_257 + __v_260);
-        let __v_264: G = (__v_259 + __v_254);
-        let __u32_sum: u128 = u128::from(((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8) | (__v_11.as_canonical_u64() << 16) | (__v_12.as_canonical_u64() << 24))) + u128::from(((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8) | (__v_27.as_canonical_u64() << 16) | (__v_28.as_canonical_u64() << 24))) + u128::from(((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8) | (__v_83.as_canonical_u64() << 16) | (__v_84.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_265: G = G::from_u8(__u32_bytes[0]);
-        let __v_266: G = G::from_u8(__u32_bytes[1]);
-        let __v_267: G = G::from_u8(__u32_bytes[2]);
-        let __v_268: G = G::from_u8(__u32_bytes[3]);
-        let __v_269: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_265; let __vj = __v_266; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_267; let __vj = __v_268; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_270: G = G::from_u64(1);
-        let __v_271: G = (__v_269 - __v_270);
-        let __v_272: G = G::from_u64(2);
-        let __v_273: G = (__v_269 - __v_272);
-        let __v_274: G = (__v_271 * __v_273);
-        let __v_275: G = (__v_269 * __v_274);
-        let __v_276: G = G::from_u64(0);
-        if (__v_275 != __v_276) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_275.as_canonical_u64(), rhs: __v_276.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) };
-        let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) };
-        let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) };
-        let __v_280: G = if unconstrained { Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record) };
-        let __u32_sum: u128 = u128::from(((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8) | (__v_43.as_canonical_u64() << 16) | (__v_44.as_canonical_u64() << 24))) + u128::from(((__v_279.as_canonical_u64() << 0) | (__v_280.as_canonical_u64() << 8) | (__v_277.as_canonical_u64() << 16) | (__v_278.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_281: G = G::from_u8(__u32_bytes[0]);
-        let __v_282: G = G::from_u8(__u32_bytes[1]);
-        let __v_283: G = G::from_u8(__u32_bytes[2]);
-        let __v_284: G = G::from_u8(__u32_bytes[3]);
-        let __v_285: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_281; let __vj = __v_282; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_283; let __vj = __v_284; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_286: G = (__v_285 * __v_285);
-        if (__v_286 != __v_285) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_286.as_canonical_u64(), rhs: __v_285.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) };
-        let __v_287: G = __b2_out.0;
-        let __v_288: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) };
-        let __v_289: G = __b2_out.0;
-        let __v_290: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) };
-        let __v_291: G = __b2_out.0;
-        let __v_292: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record) };
-        let __v_293: G = __b2_out.0;
-        let __v_294: G = __b2_out.1;
-        let __v_295: G = (__v_289 + __v_292);
-        let __v_296: G = (__v_291 + __v_294);
-        let __v_297: G = (__v_293 + __v_288);
-        let __v_298: G = (__v_287 + __v_290);
-        let __u32_sum: u128 = u128::from(((__v_265.as_canonical_u64() << 0) | (__v_266.as_canonical_u64() << 8) | (__v_267.as_canonical_u64() << 16) | (__v_268.as_canonical_u64() << 24))) + u128::from(((__v_295.as_canonical_u64() << 0) | (__v_296.as_canonical_u64() << 8) | (__v_297.as_canonical_u64() << 16) | (__v_298.as_canonical_u64() << 24))) + u128::from(((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8) | (__v_87.as_canonical_u64() << 16) | (__v_88.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_299: G = G::from_u8(__u32_bytes[0]);
-        let __v_300: G = G::from_u8(__u32_bytes[1]);
-        let __v_301: G = G::from_u8(__u32_bytes[2]);
-        let __v_302: G = G::from_u8(__u32_bytes[3]);
-        let __v_303: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_304: G = G::from_u64(1);
-        let __v_305: G = (__v_303 - __v_304);
-        let __v_306: G = G::from_u64(2);
-        let __v_307: G = (__v_303 - __v_306);
-        let __v_308: G = (__v_305 * __v_307);
-        let __v_309: G = (__v_303 * __v_308);
-        let __v_310: G = G::from_u64(0);
-        if (__v_309 != __v_310) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_310.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) };
-        let __v_312: G = if unconstrained { Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record) };
-        let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) };
-        let __v_314: G = if unconstrained { Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record) };
-        let __u32_sum: u128 = u128::from(((__v_281.as_canonical_u64() << 0) | (__v_282.as_canonical_u64() << 8) | (__v_283.as_canonical_u64() << 16) | (__v_284.as_canonical_u64() << 24))) + u128::from(((__v_312.as_canonical_u64() << 0) | (__v_313.as_canonical_u64() << 8) | (__v_314.as_canonical_u64() << 16) | (__v_311.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_315: G = G::from_u8(__u32_bytes[0]);
-        let __v_316: G = G::from_u8(__u32_bytes[1]);
-        let __v_317: G = G::from_u8(__u32_bytes[2]);
-        let __v_318: G = G::from_u8(__u32_bytes[3]);
-        let __v_319: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_315; let __vj = __v_316; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_320: G = (__v_319 * __v_319);
-        if (__v_320 != __v_319) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_320.as_canonical_u64(), rhs: __v_319.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) };
-        let __v_321: G = __b2_out.0;
-        let __v_322: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) };
-        let __v_323: G = __b2_out.0;
-        let __v_324: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) };
-        let __v_325: G = __b2_out.0;
-        let __v_326: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record) };
-        let __v_327: G = __b2_out.0;
-        let __v_328: G = __b2_out.1;
-        let __v_329: G = (__v_321 + __v_324);
-        let __v_330: G = (__v_323 + __v_326);
-        let __v_331: G = (__v_325 + __v_328);
-        let __v_332: G = (__v_327 + __v_322);
-        let __u32_sum: u128 = u128::from(((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8) | (__v_15.as_canonical_u64() << 16) | (__v_16.as_canonical_u64() << 24))) + u128::from(((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8) | (__v_31.as_canonical_u64() << 16) | (__v_32.as_canonical_u64() << 24))) + u128::from(((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8) | (__v_91.as_canonical_u64() << 16) | (__v_92.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_333: G = G::from_u8(__u32_bytes[0]);
-        let __v_334: G = G::from_u8(__u32_bytes[1]);
-        let __v_335: G = G::from_u8(__u32_bytes[2]);
-        let __v_336: G = G::from_u8(__u32_bytes[3]);
-        let __v_337: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_335; let __vj = __v_336; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_338: G = G::from_u64(1);
-        let __v_339: G = (__v_337 - __v_338);
-        let __v_340: G = G::from_u64(2);
-        let __v_341: G = (__v_337 - __v_340);
-        let __v_342: G = (__v_339 * __v_341);
-        let __v_343: G = (__v_337 * __v_342);
-        let __v_344: G = G::from_u64(0);
-        if (__v_343 != __v_344) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_343.as_canonical_u64(), rhs: __v_344.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) };
-        let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) };
-        let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) };
-        let __v_348: G = if unconstrained { Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record) };
-        let __u32_sum: u128 = u128::from(((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8) | (__v_47.as_canonical_u64() << 16) | (__v_48.as_canonical_u64() << 24))) + u128::from(((__v_347.as_canonical_u64() << 0) | (__v_348.as_canonical_u64() << 8) | (__v_345.as_canonical_u64() << 16) | (__v_346.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_349: G = G::from_u8(__u32_bytes[0]);
-        let __v_350: G = G::from_u8(__u32_bytes[1]);
-        let __v_351: G = G::from_u8(__u32_bytes[2]);
-        let __v_352: G = G::from_u8(__u32_bytes[3]);
-        let __v_353: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_354: G = (__v_353 * __v_353);
-        if (__v_354 != __v_353) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_354.as_canonical_u64(), rhs: __v_353.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) };
-        let __v_355: G = __b2_out.0;
-        let __v_356: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) };
-        let __v_357: G = __b2_out.0;
-        let __v_358: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) };
-        let __v_359: G = __b2_out.0;
-        let __v_360: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record) };
-        let __v_361: G = __b2_out.0;
-        let __v_362: G = __b2_out.1;
-        let __v_363: G = (__v_357 + __v_360);
-        let __v_364: G = (__v_359 + __v_362);
-        let __v_365: G = (__v_361 + __v_356);
-        let __v_366: G = (__v_355 + __v_358);
-        let __u32_sum: u128 = u128::from(((__v_333.as_canonical_u64() << 0) | (__v_334.as_canonical_u64() << 8) | (__v_335.as_canonical_u64() << 16) | (__v_336.as_canonical_u64() << 24))) + u128::from(((__v_363.as_canonical_u64() << 0) | (__v_364.as_canonical_u64() << 8) | (__v_365.as_canonical_u64() << 16) | (__v_366.as_canonical_u64() << 24))) + u128::from(((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8) | (__v_95.as_canonical_u64() << 16) | (__v_96.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_367: G = G::from_u8(__u32_bytes[0]);
-        let __v_368: G = G::from_u8(__u32_bytes[1]);
-        let __v_369: G = G::from_u8(__u32_bytes[2]);
-        let __v_370: G = G::from_u8(__u32_bytes[3]);
-        let __v_371: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_367; let __vj = __v_368; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_369; let __vj = __v_370; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_372: G = G::from_u64(1);
-        let __v_373: G = (__v_371 - __v_372);
-        let __v_374: G = G::from_u64(2);
-        let __v_375: G = (__v_371 - __v_374);
-        let __v_376: G = (__v_373 * __v_375);
-        let __v_377: G = (__v_371 * __v_376);
-        let __v_378: G = G::from_u64(0);
-        if (__v_377 != __v_378) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_377.as_canonical_u64(), rhs: __v_378.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) };
-        let __v_380: G = if unconstrained { Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record) };
-        let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) };
-        let __v_382: G = if unconstrained { Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record) };
-        let __u32_sum: u128 = u128::from(((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8) | (__v_351.as_canonical_u64() << 16) | (__v_352.as_canonical_u64() << 24))) + u128::from(((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8) | (__v_382.as_canonical_u64() << 16) | (__v_379.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_383: G = G::from_u8(__u32_bytes[0]);
-        let __v_384: G = G::from_u8(__u32_bytes[1]);
-        let __v_385: G = G::from_u8(__u32_bytes[2]);
-        let __v_386: G = G::from_u8(__u32_bytes[3]);
-        let __v_387: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_383; let __vj = __v_384; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_385; let __vj = __v_386; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_388: G = (__v_387 * __v_387);
-        if (__v_388 != __v_387) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) };
-        let __v_389: G = __b2_out.0;
-        let __v_390: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) };
-        let __v_391: G = __b2_out.0;
-        let __v_392: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) };
-        let __v_393: G = __b2_out.0;
-        let __v_394: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record) };
-        let __v_395: G = __b2_out.0;
-        let __v_396: G = __b2_out.1;
-        let __v_397: G = (__v_389 + __v_392);
-        let __v_398: G = (__v_391 + __v_394);
-        let __v_399: G = (__v_393 + __v_396);
-        let __v_400: G = (__v_395 + __v_390);
-        let __u32_sum: u128 = u128::from(((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8) | (__v_165.as_canonical_u64() << 16) | (__v_166.as_canonical_u64() << 24))) + u128::from(((__v_261.as_canonical_u64() << 0) | (__v_262.as_canonical_u64() << 8) | (__v_263.as_canonical_u64() << 16) | (__v_264.as_canonical_u64() << 24))) + u128::from(((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8) | (__v_99.as_canonical_u64() << 16) | (__v_100.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_401: G = G::from_u8(__u32_bytes[0]);
-        let __v_402: G = G::from_u8(__u32_bytes[1]);
-        let __v_403: G = G::from_u8(__u32_bytes[2]);
-        let __v_404: G = G::from_u8(__u32_bytes[3]);
-        let __v_405: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_401; let __vj = __v_402; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_403; let __vj = __v_404; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_406: G = G::from_u64(1);
-        let __v_407: G = (__v_405 - __v_406);
-        let __v_408: G = G::from_u64(2);
-        let __v_409: G = (__v_405 - __v_408);
-        let __v_410: G = (__v_407 * __v_409);
-        let __v_411: G = (__v_405 * __v_410);
-        let __v_412: G = G::from_u64(0);
-        if (__v_411 != __v_412) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) };
-        let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) };
-        let __v_415: G = if unconstrained { Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record) };
-        let __v_416: G = if unconstrained { Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record) };
-        let __u32_sum: u128 = u128::from(((__v_315.as_canonical_u64() << 0) | (__v_316.as_canonical_u64() << 8) | (__v_317.as_canonical_u64() << 16) | (__v_318.as_canonical_u64() << 24))) + u128::from(((__v_415.as_canonical_u64() << 0) | (__v_416.as_canonical_u64() << 8) | (__v_413.as_canonical_u64() << 16) | (__v_414.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_417: G = G::from_u8(__u32_bytes[0]);
-        let __v_418: G = G::from_u8(__u32_bytes[1]);
-        let __v_419: G = G::from_u8(__u32_bytes[2]);
-        let __v_420: G = G::from_u8(__u32_bytes[3]);
-        let __v_421: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_417; let __vj = __v_418; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_419; let __vj = __v_420; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_422: G = (__v_421 * __v_421);
-        if (__v_422 != __v_421) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_422.as_canonical_u64(), rhs: __v_421.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) };
-        let __v_423: G = __b2_out.0;
-        let __v_424: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) };
-        let __v_425: G = __b2_out.0;
-        let __v_426: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) };
-        let __v_427: G = __b2_out.0;
-        let __v_428: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record) };
-        let __v_429: G = __b2_out.0;
-        let __v_430: G = __b2_out.1;
-        let __v_431: G = (__v_425 + __v_428);
-        let __v_432: G = (__v_427 + __v_430);
-        let __v_433: G = (__v_429 + __v_424);
-        let __v_434: G = (__v_423 + __v_426);
-        let __u32_sum: u128 = u128::from(((__v_401.as_canonical_u64() << 0) | (__v_402.as_canonical_u64() << 8) | (__v_403.as_canonical_u64() << 16) | (__v_404.as_canonical_u64() << 24))) + u128::from(((__v_431.as_canonical_u64() << 0) | (__v_432.as_canonical_u64() << 8) | (__v_433.as_canonical_u64() << 16) | (__v_434.as_canonical_u64() << 24))) + u128::from(((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8) | (__v_103.as_canonical_u64() << 16) | (__v_104.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_435: G = G::from_u8(__u32_bytes[0]);
-        let __v_436: G = G::from_u8(__u32_bytes[1]);
-        let __v_437: G = G::from_u8(__u32_bytes[2]);
-        let __v_438: G = G::from_u8(__u32_bytes[3]);
-        let __v_439: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_435; let __vj = __v_436; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_437; let __vj = __v_438; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_440: G = G::from_u64(1);
-        let __v_441: G = (__v_439 - __v_440);
-        let __v_442: G = G::from_u64(2);
-        let __v_443: G = (__v_439 - __v_442);
-        let __v_444: G = (__v_441 * __v_443);
-        let __v_445: G = (__v_439 * __v_444);
-        let __v_446: G = G::from_u64(0);
-        if (__v_445 != __v_446) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_445.as_canonical_u64(), rhs: __v_446.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) };
-        let __v_448: G = if unconstrained { Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record) };
-        let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) };
-        let __v_450: G = if unconstrained { Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record) };
-        let __u32_sum: u128 = u128::from(((__v_417.as_canonical_u64() << 0) | (__v_418.as_canonical_u64() << 8) | (__v_419.as_canonical_u64() << 16) | (__v_420.as_canonical_u64() << 24))) + u128::from(((__v_448.as_canonical_u64() << 0) | (__v_449.as_canonical_u64() << 8) | (__v_450.as_canonical_u64() << 16) | (__v_447.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_451: G = G::from_u8(__u32_bytes[0]);
-        let __v_452: G = G::from_u8(__u32_bytes[1]);
-        let __v_453: G = G::from_u8(__u32_bytes[2]);
-        let __v_454: G = G::from_u8(__u32_bytes[3]);
-        let __v_455: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_451; let __vj = __v_452; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_453; let __vj = __v_454; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_456: G = (__v_455 * __v_455);
-        if (__v_456 != __v_455) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) };
-        let __v_457: G = __b2_out.0;
-        let __v_458: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) };
-        let __v_459: G = __b2_out.0;
-        let __v_460: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) };
-        let __v_461: G = __b2_out.0;
-        let __v_462: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record) };
-        let __v_463: G = __b2_out.0;
-        let __v_464: G = __b2_out.1;
-        let __v_465: G = (__v_457 + __v_460);
-        let __v_466: G = (__v_459 + __v_462);
-        let __v_467: G = (__v_461 + __v_464);
-        let __v_468: G = (__v_463 + __v_458);
-        let __u32_sum: u128 = u128::from(((__v_231.as_canonical_u64() << 0) | (__v_232.as_canonical_u64() << 8) | (__v_233.as_canonical_u64() << 16) | (__v_234.as_canonical_u64() << 24))) + u128::from(((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8) | (__v_331.as_canonical_u64() << 16) | (__v_332.as_canonical_u64() << 24))) + u128::from(((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8) | (__v_107.as_canonical_u64() << 16) | (__v_108.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_469: G = G::from_u8(__u32_bytes[0]);
-        let __v_470: G = G::from_u8(__u32_bytes[1]);
-        let __v_471: G = G::from_u8(__u32_bytes[2]);
-        let __v_472: G = G::from_u8(__u32_bytes[3]);
-        let __v_473: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_469; let __vj = __v_470; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_471; let __vj = __v_472; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_474: G = G::from_u64(1);
-        let __v_475: G = (__v_473 - __v_474);
-        let __v_476: G = G::from_u64(2);
-        let __v_477: G = (__v_473 - __v_476);
-        let __v_478: G = (__v_475 * __v_477);
-        let __v_479: G = (__v_473 * __v_478);
-        let __v_480: G = G::from_u64(0);
-        if (__v_479 != __v_480) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_480.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) };
-        let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) };
-        let __v_483: G = if unconstrained { Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record) };
-        let __v_484: G = if unconstrained { Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record) };
-        let __u32_sum: u128 = u128::from(((__v_383.as_canonical_u64() << 0) | (__v_384.as_canonical_u64() << 8) | (__v_385.as_canonical_u64() << 16) | (__v_386.as_canonical_u64() << 24))) + u128::from(((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8) | (__v_481.as_canonical_u64() << 16) | (__v_482.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_485: G = G::from_u8(__u32_bytes[0]);
-        let __v_486: G = G::from_u8(__u32_bytes[1]);
-        let __v_487: G = G::from_u8(__u32_bytes[2]);
-        let __v_488: G = G::from_u8(__u32_bytes[3]);
-        let __v_489: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_490: G = (__v_489 * __v_489);
-        if (__v_490 != __v_489) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) };
-        let __v_491: G = __b2_out.0;
-        let __v_492: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) };
-        let __v_493: G = __b2_out.0;
-        let __v_494: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) };
-        let __v_495: G = __b2_out.0;
-        let __v_496: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record) };
-        let __v_497: G = __b2_out.0;
-        let __v_498: G = __b2_out.1;
-        let __v_499: G = (__v_493 + __v_496);
-        let __v_500: G = (__v_495 + __v_498);
-        let __v_501: G = (__v_497 + __v_492);
-        let __v_502: G = (__v_491 + __v_494);
-        let __u32_sum: u128 = u128::from(((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8) | (__v_471.as_canonical_u64() << 16) | (__v_472.as_canonical_u64() << 24))) + u128::from(((__v_499.as_canonical_u64() << 0) | (__v_500.as_canonical_u64() << 8) | (__v_501.as_canonical_u64() << 16) | (__v_502.as_canonical_u64() << 24))) + u128::from(((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8) | (__v_111.as_canonical_u64() << 16) | (__v_112.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_503: G = G::from_u8(__u32_bytes[0]);
-        let __v_504: G = G::from_u8(__u32_bytes[1]);
-        let __v_505: G = G::from_u8(__u32_bytes[2]);
-        let __v_506: G = G::from_u8(__u32_bytes[3]);
-        let __v_507: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_508: G = G::from_u64(1);
-        let __v_509: G = (__v_507 - __v_508);
-        let __v_510: G = G::from_u64(2);
-        let __v_511: G = (__v_507 - __v_510);
-        let __v_512: G = (__v_509 * __v_511);
-        let __v_513: G = (__v_507 * __v_512);
-        let __v_514: G = G::from_u64(0);
-        if (__v_513 != __v_514) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) };
-        let __v_516: G = if unconstrained { Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record) };
-        let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) };
-        let __v_518: G = if unconstrained { Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record) };
-        let __u32_sum: u128 = u128::from(((__v_485.as_canonical_u64() << 0) | (__v_486.as_canonical_u64() << 8) | (__v_487.as_canonical_u64() << 16) | (__v_488.as_canonical_u64() << 24))) + u128::from(((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8) | (__v_518.as_canonical_u64() << 16) | (__v_515.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_519: G = G::from_u8(__u32_bytes[0]);
-        let __v_520: G = G::from_u8(__u32_bytes[1]);
-        let __v_521: G = G::from_u8(__u32_bytes[2]);
-        let __v_522: G = G::from_u8(__u32_bytes[3]);
-        let __v_523: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_521; let __vj = __v_522; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_524: G = (__v_523 * __v_523);
-        if (__v_524 != __v_523) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_524.as_canonical_u64(), rhs: __v_523.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) };
-        let __v_525: G = __b2_out.0;
-        let __v_526: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) };
-        let __v_527: G = __b2_out.0;
-        let __v_528: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) };
-        let __v_529: G = __b2_out.0;
-        let __v_530: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record) };
-        let __v_531: G = __b2_out.0;
-        let __v_532: G = __b2_out.1;
-        let __v_533: G = (__v_525 + __v_528);
-        let __v_534: G = (__v_527 + __v_530);
-        let __v_535: G = (__v_529 + __v_532);
-        let __v_536: G = (__v_531 + __v_526);
-        let __u32_sum: u128 = u128::from(((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8) | (__v_301.as_canonical_u64() << 16) | (__v_302.as_canonical_u64() << 24))) + u128::from(((__v_397.as_canonical_u64() << 0) | (__v_398.as_canonical_u64() << 8) | (__v_399.as_canonical_u64() << 16) | (__v_400.as_canonical_u64() << 24))) + u128::from(((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8) | (__v_115.as_canonical_u64() << 16) | (__v_116.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_537: G = G::from_u8(__u32_bytes[0]);
-        let __v_538: G = G::from_u8(__u32_bytes[1]);
-        let __v_539: G = G::from_u8(__u32_bytes[2]);
-        let __v_540: G = G::from_u8(__u32_bytes[3]);
-        let __v_541: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_539; let __vj = __v_540; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_542: G = G::from_u64(1);
-        let __v_543: G = (__v_541 - __v_542);
-        let __v_544: G = G::from_u64(2);
-        let __v_545: G = (__v_541 - __v_544);
-        let __v_546: G = (__v_543 * __v_545);
-        let __v_547: G = (__v_541 * __v_546);
-        let __v_548: G = G::from_u64(0);
-        if (__v_547 != __v_548) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_547.as_canonical_u64(), rhs: __v_548.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) };
-        let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) };
-        let __v_551: G = if unconstrained { Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record) };
-        let __v_552: G = if unconstrained { Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record) };
-        let __u32_sum: u128 = u128::from(((__v_179.as_canonical_u64() << 0) | (__v_180.as_canonical_u64() << 8) | (__v_181.as_canonical_u64() << 16) | (__v_182.as_canonical_u64() << 24))) + u128::from(((__v_551.as_canonical_u64() << 0) | (__v_552.as_canonical_u64() << 8) | (__v_549.as_canonical_u64() << 16) | (__v_550.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_553: G = G::from_u8(__u32_bytes[0]);
-        let __v_554: G = G::from_u8(__u32_bytes[1]);
-        let __v_555: G = G::from_u8(__u32_bytes[2]);
-        let __v_556: G = G::from_u8(__u32_bytes[3]);
-        let __v_557: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_553; let __vj = __v_554; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_555; let __vj = __v_556; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_558: G = (__v_557 * __v_557);
-        if (__v_558 != __v_557) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_558.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) };
-        let __v_559: G = __b2_out.0;
-        let __v_560: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) };
-        let __v_561: G = __b2_out.0;
-        let __v_562: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) };
-        let __v_563: G = __b2_out.0;
-        let __v_564: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record) };
-        let __v_565: G = __b2_out.0;
-        let __v_566: G = __b2_out.1;
-        let __v_567: G = (__v_561 + __v_564);
-        let __v_568: G = (__v_563 + __v_566);
-        let __v_569: G = (__v_565 + __v_560);
-        let __v_570: G = (__v_559 + __v_562);
-        let __u32_sum: u128 = u128::from(((__v_537.as_canonical_u64() << 0) | (__v_538.as_canonical_u64() << 8) | (__v_539.as_canonical_u64() << 16) | (__v_540.as_canonical_u64() << 24))) + u128::from(((__v_567.as_canonical_u64() << 0) | (__v_568.as_canonical_u64() << 8) | (__v_569.as_canonical_u64() << 16) | (__v_570.as_canonical_u64() << 24))) + u128::from(((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8) | (__v_119.as_canonical_u64() << 16) | (__v_120.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_571: G = G::from_u8(__u32_bytes[0]);
-        let __v_572: G = G::from_u8(__u32_bytes[1]);
-        let __v_573: G = G::from_u8(__u32_bytes[2]);
-        let __v_574: G = G::from_u8(__u32_bytes[3]);
-        let __v_575: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_571; let __vj = __v_572; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_573; let __vj = __v_574; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_576: G = G::from_u64(1);
-        let __v_577: G = (__v_575 - __v_576);
-        let __v_578: G = G::from_u64(2);
-        let __v_579: G = (__v_575 - __v_578);
-        let __v_580: G = (__v_577 * __v_579);
-        let __v_581: G = (__v_575 * __v_580);
-        let __v_582: G = G::from_u64(0);
-        if (__v_581 != __v_582) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_581.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) };
-        let __v_584: G = if unconstrained { Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record) };
-        let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) };
-        let __v_586: G = if unconstrained { Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record) };
-        let __u32_sum: u128 = u128::from(((__v_553.as_canonical_u64() << 0) | (__v_554.as_canonical_u64() << 8) | (__v_555.as_canonical_u64() << 16) | (__v_556.as_canonical_u64() << 24))) + u128::from(((__v_584.as_canonical_u64() << 0) | (__v_585.as_canonical_u64() << 8) | (__v_586.as_canonical_u64() << 16) | (__v_583.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_587: G = G::from_u8(__u32_bytes[0]);
-        let __v_588: G = G::from_u8(__u32_bytes[1]);
-        let __v_589: G = G::from_u8(__u32_bytes[2]);
-        let __v_590: G = G::from_u8(__u32_bytes[3]);
-        let __v_591: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_587; let __vj = __v_588; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_589; let __vj = __v_590; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_592: G = (__v_591 * __v_591);
-        if (__v_592 != __v_591) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_592.as_canonical_u64(), rhs: __v_591.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) };
-        let __v_593: G = __b2_out.0;
-        let __v_594: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) };
-        let __v_595: G = __b2_out.0;
-        let __v_596: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) };
-        let __v_597: G = __b2_out.0;
-        let __v_598: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record) };
-        let __v_599: G = __b2_out.0;
-        let __v_600: G = __b2_out.1;
-        let __v_601: G = (__v_593 + __v_596);
-        let __v_602: G = (__v_595 + __v_598);
-        let __v_603: G = (__v_597 + __v_600);
-        let __v_604: G = (__v_599 + __v_594);
-        let __u32_sum: u128 = u128::from(((__v_367.as_canonical_u64() << 0) | (__v_368.as_canonical_u64() << 8) | (__v_369.as_canonical_u64() << 16) | (__v_370.as_canonical_u64() << 24))) + u128::from(((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8) | (__v_195.as_canonical_u64() << 16) | (__v_196.as_canonical_u64() << 24))) + u128::from(((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8) | (__v_123.as_canonical_u64() << 16) | (__v_124.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_605: G = G::from_u8(__u32_bytes[0]);
-        let __v_606: G = G::from_u8(__u32_bytes[1]);
-        let __v_607: G = G::from_u8(__u32_bytes[2]);
-        let __v_608: G = G::from_u8(__u32_bytes[3]);
-        let __v_609: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_605; let __vj = __v_606; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_607; let __vj = __v_608; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_610: G = G::from_u64(1);
-        let __v_611: G = (__v_609 - __v_610);
-        let __v_612: G = G::from_u64(2);
-        let __v_613: G = (__v_609 - __v_612);
-        let __v_614: G = (__v_611 * __v_613);
-        let __v_615: G = (__v_609 * __v_614);
-        let __v_616: G = G::from_u64(0);
-        if (__v_615 != __v_616) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_616.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) };
-        let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) };
-        let __v_619: G = if unconstrained { Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record) };
-        let __v_620: G = if unconstrained { Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record) };
-        let __u32_sum: u128 = u128::from(((__v_247.as_canonical_u64() << 0) | (__v_248.as_canonical_u64() << 8) | (__v_249.as_canonical_u64() << 16) | (__v_250.as_canonical_u64() << 24))) + u128::from(((__v_619.as_canonical_u64() << 0) | (__v_620.as_canonical_u64() << 8) | (__v_617.as_canonical_u64() << 16) | (__v_618.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_621: G = G::from_u8(__u32_bytes[0]);
-        let __v_622: G = G::from_u8(__u32_bytes[1]);
-        let __v_623: G = G::from_u8(__u32_bytes[2]);
-        let __v_624: G = G::from_u8(__u32_bytes[3]);
-        let __v_625: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_621; let __vj = __v_622; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_623; let __vj = __v_624; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_626: G = (__v_625 * __v_625);
-        if (__v_626 != __v_625) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_626.as_canonical_u64(), rhs: __v_625.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) };
-        let __v_627: G = __b2_out.0;
-        let __v_628: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) };
-        let __v_629: G = __b2_out.0;
-        let __v_630: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) };
-        let __v_631: G = __b2_out.0;
-        let __v_632: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record) };
-        let __v_633: G = __b2_out.0;
-        let __v_634: G = __b2_out.1;
-        let __v_635: G = (__v_629 + __v_632);
-        let __v_636: G = (__v_631 + __v_634);
-        let __v_637: G = (__v_633 + __v_628);
-        let __v_638: G = (__v_627 + __v_630);
-        let __u32_sum: u128 = u128::from(((__v_605.as_canonical_u64() << 0) | (__v_606.as_canonical_u64() << 8) | (__v_607.as_canonical_u64() << 16) | (__v_608.as_canonical_u64() << 24))) + u128::from(((__v_635.as_canonical_u64() << 0) | (__v_636.as_canonical_u64() << 8) | (__v_637.as_canonical_u64() << 16) | (__v_638.as_canonical_u64() << 24))) + u128::from(((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8) | (__v_127.as_canonical_u64() << 16) | (__v_128.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_639: G = G::from_u8(__u32_bytes[0]);
-        let __v_640: G = G::from_u8(__u32_bytes[1]);
-        let __v_641: G = G::from_u8(__u32_bytes[2]);
-        let __v_642: G = G::from_u8(__u32_bytes[3]);
-        let __v_643: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_639; let __vj = __v_640; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_641; let __vj = __v_642; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_644: G = G::from_u64(1);
-        let __v_645: G = (__v_643 - __v_644);
-        let __v_646: G = G::from_u64(2);
-        let __v_647: G = (__v_643 - __v_646);
-        let __v_648: G = (__v_645 * __v_647);
-        let __v_649: G = (__v_643 * __v_648);
-        let __v_650: G = G::from_u64(0);
-        if (__v_649 != __v_650) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-        }
-        let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) };
-        let __v_652: G = if unconstrained { Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record) };
-        let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) };
-        let __v_654: G = if unconstrained { Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record) };
-        let __u32_sum: u128 = u128::from(((__v_621.as_canonical_u64() << 0) | (__v_622.as_canonical_u64() << 8) | (__v_623.as_canonical_u64() << 16) | (__v_624.as_canonical_u64() << 24))) + u128::from(((__v_652.as_canonical_u64() << 0) | (__v_653.as_canonical_u64() << 8) | (__v_654.as_canonical_u64() << 16) | (__v_651.as_canonical_u64() << 24)));
-        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-        let __v_655: G = G::from_u8(__u32_bytes[0]);
-        let __v_656: G = G::from_u8(__u32_bytes[1]);
-        let __v_657: G = G::from_u8(__u32_bytes[2]);
-        let __v_658: G = G::from_u8(__u32_bytes[3]);
-        let __v_659: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-        if !unconstrained { let __vi = __v_655; let __vj = __v_656; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_657; let __vj = __v_658; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_660: G = (__v_659 * __v_659);
-        if (__v_660 != __v_659) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_660.as_canonical_u64(), rhs: __v_659.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
-        }
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) };
-        let __v_661: G = __b2_out.0;
-        let __v_662: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) };
-        let __v_663: G = __b2_out.0;
-        let __v_664: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) };
-        let __v_665: G = __b2_out.0;
-        let __v_666: G = __b2_out.1;
-        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record) };
-        let __v_667: G = __b2_out.0;
-        let __v_668: G = __b2_out.1;
-        let __v_669: G = (__v_661 + __v_664);
-        let __v_670: G = (__v_663 + __v_666);
-        let __v_671: G = (__v_665 + __v_668);
-        let __v_672: G = (__v_667 + __v_662);
-        let __v_673: G = G::from_u64(1);
-        let __v_674: G = (__v_0 + __v_673);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-        let __v_675: G = __r_arr[0];
-        let __v_676: G = __r_arr[1];
-        let __v_677: G = __r_arr[2];
-        let __v_678: G = __r_arr[3];
-        let __v_679: G = __r_arr[4];
-        let __v_680: G = __r_arr[5];
-        let __v_681: G = __r_arr[6];
-        let __v_682: G = __r_arr[7];
-        let __v_683: G = __r_arr[8];
-        let __v_684: G = __r_arr[9];
-        let __v_685: G = __r_arr[10];
-        let __v_686: G = __r_arr[11];
-        let __v_687: G = __r_arr[12];
-        let __v_688: G = __r_arr[13];
-        let __v_689: G = __r_arr[14];
-        let __v_690: G = __r_arr[15];
-        let __v_691: G = __r_arr[16];
-        let __v_692: G = __r_arr[17];
-        let __v_693: G = __r_arr[18];
-        let __v_694: G = __r_arr[19];
-        let __v_695: G = __r_arr[20];
-        let __v_696: G = __r_arr[21];
-        let __v_697: G = __r_arr[22];
-        let __v_698: G = __r_arr[23];
-        let __v_699: G = __r_arr[24];
-        let __v_700: G = __r_arr[25];
-        let __v_701: G = __r_arr[26];
-        let __v_702: G = __r_arr[27];
-        let __v_703: G = __r_arr[28];
-        let __v_704: G = __r_arr[29];
-        let __v_705: G = __r_arr[30];
-        let __v_706: G = __r_arr[31];
-        let __ret: [G; OUT_73] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706];
-        if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_74: usize = 1;
-const IN_74: usize = 1;
-const OUT_74: usize = 2;
-fn aiur_fn_74(
-  inp: [G; IN_74],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_74], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_74] = [__v_2, __v_3];
-        if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_75: usize = 1;
-const IN_75: usize = 1;
-const OUT_75: usize = 2;
-fn aiur_fn_75(
-  inp: [G; IN_75],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_75], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __ret: [G; OUT_75] = [__v_1, __v_2];
-    if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_76: usize = 1;
-const IN_76: usize = 1;
-const OUT_76: usize = 2;
-fn aiur_fn_76(
-  inp: [G; IN_76],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_76], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __v_5: G = G::from_u64(256);
-    let __v_6: G = (__v_5 * __v_3);
-    let __v_7: G = (__v_1 + __v_6);
-    let __ret: [G; OUT_76] = [__v_7, __v_4];
-    if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_77: usize = 1;
-const IN_77: usize = 1;
-const OUT_77: usize = 10;
-fn aiur_fn_77(
-  inp: [G; IN_77],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_77], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __v_5: G = G::from_u64(256);
-    let __v_6: G = (__v_5 * __v_3);
-    let __v_7: G = (__v_1 + __v_6);
-    let __v_8: G = G::from_u64(0);
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(0);
-    let __v_13: G = G::from_u64(0);
-    let __ret: [G; OUT_77] = [__v_7, __v_1, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4];
-    if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_78: usize = 1;
-const IN_78: usize = 1;
-const OUT_78: usize = 10;
-fn aiur_fn_78(
-  inp: [G; IN_78],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_78], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = __r_arr[1];
-    let __v_9: G = G::from_u64(256);
-    let __v_10: G = (__v_9 * __v_3);
-    let __v_11: G = G::from_u64(65536);
-    let __v_12: G = (__v_11 * __v_5);
-    let __v_13: G = G::from_u64(16777216);
-    let __v_14: G = (__v_13 * __v_7);
-    let __v_15: G = (__v_12 + __v_14);
-    let __v_16: G = (__v_10 + __v_15);
-    let __v_17: G = (__v_1 + __v_16);
-    let __v_18: G = G::from_u64(0);
-    let __v_19: G = G::from_u64(0);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = G::from_u64(0);
-    let __ret: [G; OUT_78] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_19, __v_20, __v_21, __v_8];
-    if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_79: usize = 1;
-const IN_79: usize = 1;
-const OUT_79: usize = 9;
-fn aiur_fn_79(
-  inp: [G; IN_79],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_79], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = __r_arr[1];
-    let __ret: [G; OUT_79] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
-    if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_80: usize = 1;
-const IN_80: usize = 1;
-const OUT_80: usize = 2;
-fn aiur_fn_80(
-  inp: [G; IN_80],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_80], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __v_10: G = G::from_u64(256);
-    let __v_11: G = (__v_10 * __v_2);
-    let __v_12: G = G::from_u64(65536);
-    let __v_13: G = (__v_12 * __v_3);
-    let __v_14: G = G::from_u64(16777216);
-    let __v_15: G = (__v_14 * __v_4);
-    let __v_16: G = G::from_u64(4294967296);
-    let __v_17: G = (__v_16 * __v_5);
-    let __v_18: G = G::from_u64(1099511627776);
-    let __v_19: G = (__v_18 * __v_6);
-    let __v_20: G = G::from_u64(281474976710656);
-    let __v_21: G = (__v_20 * __v_7);
-    let __v_22: G = G::from_u64(72057594037927936);
-    let __v_23: G = (__v_22 * __v_8);
-    let __v_24: G = (__v_21 + __v_23);
-    let __v_25: G = (__v_19 + __v_24);
-    let __v_26: G = (__v_17 + __v_25);
-    let __v_27: G = (__v_15 + __v_26);
-    let __v_28: G = (__v_13 + __v_27);
-    let __v_29: G = (__v_11 + __v_28);
-    let __v_30: G = (__v_1 + __v_29);
-    let __ret: [G; OUT_80] = [__v_30, __v_9];
-    if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_81: usize = 1;
-const IN_81: usize = 1;
-const OUT_81: usize = 33;
-fn aiur_fn_81(
-  inp: [G; IN_81],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_81], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = __r_arr[1];
-    let __v_12: G = __r_arr[2];
-    let __v_13: G = __r_arr[3];
-    let __v_14: G = __r_arr[4];
-    let __v_15: G = __r_arr[5];
-    let __v_16: G = __r_arr[6];
-    let __v_17: G = __r_arr[7];
-    let __v_18: G = __r_arr[8];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __v_20: G = __r_arr[1];
-    let __v_21: G = __r_arr[2];
-    let __v_22: G = __r_arr[3];
-    let __v_23: G = __r_arr[4];
-    let __v_24: G = __r_arr[5];
-    let __v_25: G = __r_arr[6];
-    let __v_26: G = __r_arr[7];
-    let __v_27: G = __r_arr[8];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-    let __v_28: G = __r_arr[0];
-    let __v_29: G = __r_arr[1];
-    let __v_30: G = __r_arr[2];
-    let __v_31: G = __r_arr[3];
-    let __v_32: G = __r_arr[4];
-    let __v_33: G = __r_arr[5];
-    let __v_34: G = __r_arr[6];
-    let __v_35: G = __r_arr[7];
-    let __v_36: G = __r_arr[8];
-    let __ret: [G; OUT_81] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-    if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_82: usize = 2;
-const IN_82: usize = 2;
-const OUT_82: usize = 2;
-fn aiur_fn_82(
-  inp: [G; IN_82],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_82], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_82] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = __r_arr[2];
-        let __v_5: G = __r_arr[3];
-        let __v_6: G = __r_arr[4];
-        let __v_7: G = __r_arr[5];
-        let __v_8: G = __r_arr[6];
-        let __v_9: G = __r_arr[7];
-        let __v_10: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __v_13: G = __r_arr[2];
-        let __v_14: G = __r_arr[3];
-        let __v_15: G = __r_arr[4];
-        let __v_16: G = __r_arr[5];
-        let __v_17: G = __r_arr[6];
-        let __v_18: G = __r_arr[7];
-        let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        let __v_22: G = __r_arr[2];
-        let __v_23: G = __r_arr[3];
-        let __v_24: G = __r_arr[4];
-        let __v_25: G = __r_arr[5];
-        let __v_26: G = __r_arr[6];
-        let __v_27: G = __r_arr[7];
-        let __v_28: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
-        let __v_31: G = __r_arr[2];
-        let __v_32: G = __r_arr[3];
-        let __v_33: G = __r_arr[4];
-        let __v_34: G = __r_arr[5];
-        let __v_35: G = __r_arr[6];
-        let __v_36: G = __r_arr[7];
-        let __v_37: G = __r_arr[8];
-        let __v_38: G = G::from_u64(1);
-        let __v_39: G = (__v_1 - __v_38);
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
-        let __v_40: G = __r_arr[0];
-        let __v_41: G = __r_arr[1];
-        let __v_42: G = G::from_u64(0);
-        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_82] = [__v_44, __v_41];
-        if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_83: usize = 2;
-const IN_83: usize = 2;
-const OUT_83: usize = 2;
-fn aiur_fn_83(
-  inp: [G; IN_83],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_83], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_83] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(0);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_13, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(0);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_13, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(2);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_13, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __v_4: G = G::from_u64(1);
-            let __v_5: G = (__v_1 - __v_4);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __v_7: G = __r_arr[1];
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(3);
-            let __v_10: G = G::from_u64(3);
-            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_11, __v_7];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __v_4: G = G::from_u64(1);
-            let __v_5: G = (__v_1 - __v_4);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __v_7: G = __r_arr[1];
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(4);
-            let __v_10: G = G::from_u64(4);
-            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_11, __v_7];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          5u64 => {
-            let __v_4: G = G::from_u64(1);
-            let __v_5: G = (__v_1 - __v_4);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __v_7: G = __r_arr[1];
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(5);
-            let __v_10: G = G::from_u64(5);
-            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_11, __v_7];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          6u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __v_7: G = __r_arr[1];
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = (__v_1 - __v_8);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = G::from_u64(6);
-            let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_15, __v_11];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          7u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __v_7: G = __r_arr[1];
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = (__v_1 - __v_8);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = G::from_u64(7);
-            let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_15, __v_11];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          8u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __v_7: G = __r_arr[1];
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = (__v_1 - __v_8);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = G::from_u64(8);
-            let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_15, __v_11];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          9u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(9);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_13, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          10u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          11u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          12u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          13u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          14u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(2);
-            let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = __r_arr[1];
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(2);
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_84: usize = 2;
-const IN_84: usize = 2;
-const OUT_84: usize = 2;
-fn aiur_fn_84(
-  inp: [G; IN_84],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_84], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_84] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_84] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_85: usize = 1;
-const IN_85: usize = 1;
-const OUT_85: usize = 3;
-fn aiur_fn_85(
-  inp: [G; IN_85],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_85], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_85] = [__v_1, __v_5, __v_6];
-    if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_86: usize = 2;
-const IN_86: usize = 2;
-const OUT_86: usize = 2;
-fn aiur_fn_86(
-  inp: [G; IN_86],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_86], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_86] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 - __v_8);
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_86] = [__v_13, __v_11];
-        if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_87: usize = 3;
-const IN_87: usize = 3;
-const OUT_87: usize = 1;
-fn aiur_fn_87(
-  inp: [G; IN_87],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_87], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_3: G = G::from_u64(0);
-        let __ret: [G; OUT_87] = [__v_3];
-        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __v_3: G = G::from_u64(1);
-            let __v_4: G = G::from_u64(1);
-            let __v_5: G = (__v_0 - __v_4);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_2 - __v_6);
-            let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = (__v_3 + __v_8);
-            let __ret: [G; OUT_87] = [__v_9];
-            if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_3: G = G::from_u64(1);
-            let __v_4: G = (__v_0 - __v_3);
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_87] = [__v_7];
-            if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_88: usize = 1;
-const IN_88: usize = 1;
-const OUT_88: usize = 63;
-fn aiur_fn_88(
-  inp: [G; IN_88],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_88], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __v_10: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    let __v_13: G = __r_arr[2];
-    let __v_14: G = __r_arr[3];
-    let __v_15: G = __r_arr[4];
-    let __v_16: G = __r_arr[5];
-    let __v_17: G = __r_arr[6];
-    let __v_18: G = __r_arr[7];
-    let __v_19: G = __r_arr[8];
-    let __v_20: G = __r_arr[9];
-    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    let __v_23: G = __r_arr[2];
-    let __v_24: G = __r_arr[3];
-    let __v_25: G = __r_arr[4];
-    let __v_26: G = __r_arr[5];
-    let __v_27: G = __r_arr[6];
-    let __v_28: G = __r_arr[7];
-    let __v_29: G = __r_arr[8];
-    let __v_30: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_31: G = __r_arr[0];
-    let __v_32: G = __r_arr[1];
-    let __v_33: G = __r_arr[2];
-    let __v_34: G = __r_arr[3];
-    let __v_35: G = __r_arr[4];
-    let __v_36: G = __r_arr[5];
-    let __v_37: G = __r_arr[6];
-    let __v_38: G = __r_arr[7];
-    let __v_39: G = __r_arr[8];
-    let __v_40: G = __r_arr[9];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
-    let __v_41: G = __r_arr[0];
-    let __v_42: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_43: G = __r_arr[0];
-    let __v_44: G = __r_arr[1];
-    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_44, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-    let __v_45: G = __r_arr[0];
-    let __v_46: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_47: G = __r_arr[0];
-    let __v_48: G = __r_arr[1];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_48, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
-    let __v_49: G = __r_arr[0];
-    let __v_50: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __v_52: G = __r_arr[1];
-    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_52, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
-    let __v_53: G = __r_arr[0];
-    let __v_54: G = __r_arr[1];
-    let __v_55: G = G::from_u64(0);
-    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_51, __v_55, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
-    let __v_56: G = __r_arr[0];
-    let __v_57: G = G::from_bool((__v_56 == G::ZERO));
-    let __v_58: G = (__v_56 + __v_57);
-    let __v_59: G = (__v_58 + __v_58);
-    let __v_60: G = (__v_47 + __v_59);
-    let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes();
-    let __v_61: G = G::from_u8(__gb[0]);
-    let __v_62: G = G::from_u8(__gb[1]);
-    let __v_63: G = G::from_u8(__gb[2]);
-    let __v_64: G = G::from_u8(__gb[3]);
-    let __v_65: G = G::from_u8(__gb[4]);
-    let __v_66: G = G::from_u8(__gb[5]);
-    let __v_67: G = G::from_u8(__gb[6]);
-    let __v_68: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_61; let __vj = __v_62; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_63; let __vj = __v_64; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_65; let __vj = __v_66; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_67; let __vj = __v_68; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_69: G = G::from_u64(1020);
-    let __v_70: G = (__v_68 - __v_69);
-    let __v_71: G = (__v_67 + __v_70);
-    let __v_72: G = (__v_66 + __v_71);
-    let __v_73: G = (__v_65 + __v_72);
-    let __v_74: G = G::from_bool((__v_73 == G::ZERO));
-    let __v_75: G = (__v_63 + __v_64);
-    let __v_76: G = (__v_62 + __v_75);
-    let __v_77: G = (__v_61 + __v_76);
-    let __v_78: G = G::from_bool((__v_77 == G::ZERO));
-    let __v_79: G = G::from_u64(256);
-    let __v_80: G = (__v_79 * __v_62);
-    let __v_81: G = G::from_u64(65536);
-    let __v_82: G = (__v_81 * __v_63);
-    let __v_83: G = G::from_u64(16777216);
-    let __v_84: G = (__v_83 * __v_64);
-    let __v_85: G = G::from_u64(4294967296);
-    let __v_86: G = (__v_85 * __v_65);
-    let __v_87: G = G::from_u64(1099511627776);
-    let __v_88: G = (__v_87 * __v_66);
-    let __v_89: G = G::from_u64(281474976710656);
-    let __v_90: G = (__v_89 * __v_67);
-    let __v_91: G = G::from_u64(72057594037927936);
-    let __v_92: G = (__v_91 * __v_68);
-    let __v_93: G = (__v_90 + __v_92);
-    let __v_94: G = (__v_88 + __v_93);
-    let __v_95: G = (__v_86 + __v_94);
-    let __v_96: G = (__v_84 + __v_95);
-    let __v_97: G = (__v_82 + __v_96);
-    let __v_98: G = (__v_80 + __v_97);
-    let __v_99: G = (__v_61 + __v_98);
-    if (__v_99 != __v_60) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
-    }
-    let __v_100: G = G::from_u64(1);
-    let __v_101: G = G::from_u64(1);
-    let __v_102: G = (__v_101 - __v_78);
-    let __v_103: G = (__v_74 * __v_102);
-    let __v_104: G = (__v_100 - __v_103);
-    let __v_105: G = G::from_u64(1);
-    if (__v_104 != __v_105) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_105.as_canonical_u64(), msg: None });
-    }
-    let __v_106: G = (__v_58 + __v_58);
-    let __gb: [u8; 8] = __v_106.as_canonical_u64().to_le_bytes();
-    let __v_107: G = G::from_u8(__gb[0]);
-    let __v_108: G = G::from_u8(__gb[1]);
-    let __v_109: G = G::from_u8(__gb[2]);
-    let __v_110: G = G::from_u8(__gb[3]);
-    let __v_111: G = G::from_u8(__gb[4]);
-    let __v_112: G = G::from_u8(__gb[5]);
-    let __v_113: G = G::from_u8(__gb[6]);
-    let __v_114: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_107; let __vj = __v_108; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_109; let __vj = __v_110; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_111; let __vj = __v_112; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_113; let __vj = __v_114; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_115: G = G::from_u64(1020);
-    let __v_116: G = (__v_114 - __v_115);
-    let __v_117: G = (__v_113 + __v_116);
-    let __v_118: G = (__v_112 + __v_117);
-    let __v_119: G = (__v_111 + __v_118);
-    let __v_120: G = G::from_bool((__v_119 == G::ZERO));
-    let __v_121: G = (__v_109 + __v_110);
-    let __v_122: G = (__v_108 + __v_121);
-    let __v_123: G = (__v_107 + __v_122);
-    let __v_124: G = G::from_bool((__v_123 == G::ZERO));
-    let __v_125: G = G::from_u64(256);
-    let __v_126: G = (__v_125 * __v_108);
-    let __v_127: G = G::from_u64(65536);
-    let __v_128: G = (__v_127 * __v_109);
-    let __v_129: G = G::from_u64(16777216);
-    let __v_130: G = (__v_129 * __v_110);
-    let __v_131: G = G::from_u64(4294967296);
-    let __v_132: G = (__v_131 * __v_111);
-    let __v_133: G = G::from_u64(1099511627776);
-    let __v_134: G = (__v_133 * __v_112);
-    let __v_135: G = G::from_u64(281474976710656);
-    let __v_136: G = (__v_135 * __v_113);
-    let __v_137: G = G::from_u64(72057594037927936);
-    let __v_138: G = (__v_137 * __v_114);
-    let __v_139: G = (__v_136 + __v_138);
-    let __v_140: G = (__v_134 + __v_139);
-    let __v_141: G = (__v_132 + __v_140);
-    let __v_142: G = (__v_130 + __v_141);
-    let __v_143: G = (__v_128 + __v_142);
-    let __v_144: G = (__v_126 + __v_143);
-    let __v_145: G = (__v_107 + __v_144);
-    if (__v_145 != __v_106) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None });
-    }
-    let __v_146: G = G::from_u64(1);
-    let __v_147: G = G::from_u64(1);
-    let __v_148: G = (__v_147 - __v_124);
-    let __v_149: G = (__v_120 * __v_148);
-    let __v_150: G = (__v_146 - __v_149);
-    let __v_151: G = G::from_u64(1);
-    if (__v_150 != __v_151) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_151.as_canonical_u64(), msg: None });
-    }
-    let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes();
-    let __v_152: G = G::from_u8(__gb[0]);
-    let __v_153: G = G::from_u8(__gb[1]);
-    let __v_154: G = G::from_u8(__gb[2]);
-    let __v_155: G = G::from_u8(__gb[3]);
-    let __v_156: G = G::from_u8(__gb[4]);
-    let __v_157: G = G::from_u8(__gb[5]);
-    let __v_158: G = G::from_u8(__gb[6]);
-    let __v_159: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_152; let __vj = __v_153; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_154; let __vj = __v_155; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_156; let __vj = __v_157; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_158; let __vj = __v_159; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_160: G = G::from_u64(1020);
-    let __v_161: G = (__v_159 - __v_160);
-    let __v_162: G = (__v_158 + __v_161);
-    let __v_163: G = (__v_157 + __v_162);
-    let __v_164: G = (__v_156 + __v_163);
-    let __v_165: G = G::from_bool((__v_164 == G::ZERO));
-    let __v_166: G = (__v_154 + __v_155);
-    let __v_167: G = (__v_153 + __v_166);
-    let __v_168: G = (__v_152 + __v_167);
-    let __v_169: G = G::from_bool((__v_168 == G::ZERO));
-    let __v_170: G = G::from_u64(256);
-    let __v_171: G = (__v_170 * __v_153);
-    let __v_172: G = G::from_u64(65536);
-    let __v_173: G = (__v_172 * __v_154);
-    let __v_174: G = G::from_u64(16777216);
-    let __v_175: G = (__v_174 * __v_155);
-    let __v_176: G = G::from_u64(4294967296);
-    let __v_177: G = (__v_176 * __v_156);
-    let __v_178: G = G::from_u64(1099511627776);
-    let __v_179: G = (__v_178 * __v_157);
-    let __v_180: G = G::from_u64(281474976710656);
-    let __v_181: G = (__v_180 * __v_158);
-    let __v_182: G = G::from_u64(72057594037927936);
-    let __v_183: G = (__v_182 * __v_159);
-    let __v_184: G = (__v_181 + __v_183);
-    let __v_185: G = (__v_179 + __v_184);
-    let __v_186: G = (__v_177 + __v_185);
-    let __v_187: G = (__v_175 + __v_186);
-    let __v_188: G = (__v_173 + __v_187);
-    let __v_189: G = (__v_171 + __v_188);
-    let __v_190: G = (__v_152 + __v_189);
-    if (__v_190 != __v_41) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None });
-    }
-    let __v_191: G = G::from_u64(1);
-    let __v_192: G = G::from_u64(1);
-    let __v_193: G = (__v_192 - __v_169);
-    let __v_194: G = (__v_165 * __v_193);
-    let __v_195: G = (__v_191 - __v_194);
-    let __v_196: G = G::from_u64(1);
-    if (__v_195 != __v_196) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None });
-    }
-    let __ret: [G; OUT_88] = [__v_45, __v_43, __v_49, __v_31, __v_53, __v_41, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_54];
-    if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_89: usize = 57;
-const IN_89: usize = 57;
-const OUT_89: usize = 1;
-fn aiur_fn_89(
-  inp: [G; IN_89],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_89], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    let __v_34: G = inp[34];
-    let __v_35: G = inp[35];
-    let __v_36: G = inp[36];
-    let __v_37: G = inp[37];
-    let __v_38: G = inp[38];
-    let __v_39: G = inp[39];
-    let __v_40: G = inp[40];
-    let __v_41: G = inp[41];
-    let __v_42: G = inp[42];
-    let __v_43: G = inp[43];
-    let __v_44: G = inp[44];
-    let __v_45: G = inp[45];
-    let __v_46: G = inp[46];
-    let __v_47: G = inp[47];
-    let __v_48: G = inp[48];
-    let __v_49: G = inp[49];
-    let __v_50: G = inp[50];
-    let __v_51: G = inp[51];
-    let __v_52: G = inp[52];
-    let __v_53: G = inp[53];
-    let __v_54: G = inp[54];
-    let __v_55: G = inp[55];
-    let __v_56: G = inp[56];
-    let __v_57: G = G::from_u64(0);
-    let __v_58: G = G::from_u64(0);
-    let __v_59: G = G::from_u64(0);
-    let __v_60: G = G::from_u64(0);
-    let __v_61: G = G::from_u64(0);
-    let __v_62: G = G::from_u64(0);
-    let __v_63: G = G::from_u64(0);
-    let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_89] = [__v_70];
-    if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_90: usize = 2;
-const IN_90: usize = 2;
-const OUT_90: usize = 3;
-fn aiur_fn_90(
-  inp: [G; IN_90],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_90], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_90] = [__v_4, __v_7, __v_0];
-        if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = __r_arr[2];
-        let __v_5: G = __r_arr[3];
-        let __v_6: G = __r_arr[4];
-        let __v_7: G = __r_arr[5];
-        let __v_8: G = __r_arr[6];
-        let __v_9: G = __r_arr[7];
-        let __v_10: G = __r_arr[8];
-        let __v_11: G = __r_arr[9];
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __v_14: G = __r_arr[2];
-        let __v_15: G = __r_arr[3];
-        let __v_16: G = __r_arr[4];
-        let __v_17: G = __r_arr[5];
-        let __v_18: G = __r_arr[6];
-        let __v_19: G = __r_arr[7];
-        let __v_20: G = __r_arr[8];
-        let __v_21: G = __r_arr[9];
-        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __v_23: G = __r_arr[1];
-        let __v_24: G = __r_arr[2];
-        let __v_25: G = __r_arr[3];
-        let __v_26: G = __r_arr[4];
-        let __v_27: G = __r_arr[5];
-        let __v_28: G = __r_arr[6];
-        let __v_29: G = __r_arr[7];
-        let __v_30: G = __r_arr[8];
-        let __v_31: G = __r_arr[9];
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-        let __v_32: G = __r_arr[0];
-        let __v_33: G = __r_arr[1];
-        let __v_34: G = __r_arr[2];
-        let __v_35: G = __r_arr[3];
-        let __v_36: G = __r_arr[4];
-        let __v_37: G = __r_arr[5];
-        let __v_38: G = __r_arr[6];
-        let __v_39: G = __r_arr[7];
-        let __v_40: G = __r_arr[8];
-        let __v_41: G = __r_arr[9];
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
-        let __v_42: G = __r_arr[0];
-        let __v_43: G = __r_arr[1];
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-        let __v_44: G = __r_arr[0];
-        let __v_45: G = __r_arr[1];
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
-        let __v_46: G = __r_arr[0];
-        let __v_47: G = __r_arr[1];
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-        let __v_48: G = __r_arr[0];
-        let __v_49: G = __r_arr[1];
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_49, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
-        let __v_50: G = __r_arr[0];
-        let __v_51: G = __r_arr[1];
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-        let __v_52: G = __r_arr[0];
-        let __v_53: G = __r_arr[1];
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_53, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
-        let __v_54: G = __r_arr[0];
-        let __v_55: G = __r_arr[1];
-        let __v_56: G = G::from_u64(0);
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_52, __v_56, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
-        let __v_57: G = __r_arr[0];
-        let __v_58: G = G::from_bool((__v_57 == G::ZERO));
-        let __v_59: G = (__v_57 + __v_58);
-        let __v_60: G = (__v_59 + __v_59);
-        let __v_61: G = (__v_48 + __v_60);
-        let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes();
-        let __v_62: G = G::from_u8(__gb[0]);
-        let __v_63: G = G::from_u8(__gb[1]);
-        let __v_64: G = G::from_u8(__gb[2]);
-        let __v_65: G = G::from_u8(__gb[3]);
-        let __v_66: G = G::from_u8(__gb[4]);
-        let __v_67: G = G::from_u8(__gb[5]);
-        let __v_68: G = G::from_u8(__gb[6]);
-        let __v_69: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_66; let __vj = __v_67; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_68; let __vj = __v_69; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_70: G = G::from_u64(1020);
-        let __v_71: G = (__v_69 - __v_70);
-        let __v_72: G = (__v_68 + __v_71);
-        let __v_73: G = (__v_67 + __v_72);
-        let __v_74: G = (__v_66 + __v_73);
-        let __v_75: G = G::from_bool((__v_74 == G::ZERO));
-        let __v_76: G = (__v_64 + __v_65);
-        let __v_77: G = (__v_63 + __v_76);
-        let __v_78: G = (__v_62 + __v_77);
-        let __v_79: G = G::from_bool((__v_78 == G::ZERO));
-        let __v_80: G = G::from_u64(256);
-        let __v_81: G = (__v_80 * __v_63);
-        let __v_82: G = G::from_u64(65536);
-        let __v_83: G = (__v_82 * __v_64);
-        let __v_84: G = G::from_u64(16777216);
-        let __v_85: G = (__v_84 * __v_65);
-        let __v_86: G = G::from_u64(4294967296);
-        let __v_87: G = (__v_86 * __v_66);
-        let __v_88: G = G::from_u64(1099511627776);
-        let __v_89: G = (__v_88 * __v_67);
-        let __v_90: G = G::from_u64(281474976710656);
-        let __v_91: G = (__v_90 * __v_68);
-        let __v_92: G = G::from_u64(72057594037927936);
-        let __v_93: G = (__v_92 * __v_69);
-        let __v_94: G = (__v_91 + __v_93);
-        let __v_95: G = (__v_89 + __v_94);
-        let __v_96: G = (__v_87 + __v_95);
-        let __v_97: G = (__v_85 + __v_96);
-        let __v_98: G = (__v_83 + __v_97);
-        let __v_99: G = (__v_81 + __v_98);
-        let __v_100: G = (__v_62 + __v_99);
-        if (__v_100 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_100.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
-        }
-        let __v_101: G = G::from_u64(1);
-        let __v_102: G = G::from_u64(1);
-        let __v_103: G = (__v_102 - __v_79);
-        let __v_104: G = (__v_75 * __v_103);
-        let __v_105: G = (__v_101 - __v_104);
-        let __v_106: G = G::from_u64(1);
-        if (__v_105 != __v_106) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None });
-        }
-        let __v_107: G = (__v_59 + __v_59);
-        let __gb: [u8; 8] = __v_107.as_canonical_u64().to_le_bytes();
-        let __v_108: G = G::from_u8(__gb[0]);
-        let __v_109: G = G::from_u8(__gb[1]);
-        let __v_110: G = G::from_u8(__gb[2]);
-        let __v_111: G = G::from_u8(__gb[3]);
-        let __v_112: G = G::from_u8(__gb[4]);
-        let __v_113: G = G::from_u8(__gb[5]);
-        let __v_114: G = G::from_u8(__gb[6]);
-        let __v_115: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_108; let __vj = __v_109; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_110; let __vj = __v_111; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_112; let __vj = __v_113; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_114; let __vj = __v_115; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_116: G = G::from_u64(1020);
-        let __v_117: G = (__v_115 - __v_116);
-        let __v_118: G = (__v_114 + __v_117);
-        let __v_119: G = (__v_113 + __v_118);
-        let __v_120: G = (__v_112 + __v_119);
-        let __v_121: G = G::from_bool((__v_120 == G::ZERO));
-        let __v_122: G = (__v_110 + __v_111);
-        let __v_123: G = (__v_109 + __v_122);
-        let __v_124: G = (__v_108 + __v_123);
-        let __v_125: G = G::from_bool((__v_124 == G::ZERO));
-        let __v_126: G = G::from_u64(256);
-        let __v_127: G = (__v_126 * __v_109);
-        let __v_128: G = G::from_u64(65536);
-        let __v_129: G = (__v_128 * __v_110);
-        let __v_130: G = G::from_u64(16777216);
-        let __v_131: G = (__v_130 * __v_111);
-        let __v_132: G = G::from_u64(4294967296);
-        let __v_133: G = (__v_132 * __v_112);
-        let __v_134: G = G::from_u64(1099511627776);
-        let __v_135: G = (__v_134 * __v_113);
-        let __v_136: G = G::from_u64(281474976710656);
-        let __v_137: G = (__v_136 * __v_114);
-        let __v_138: G = G::from_u64(72057594037927936);
-        let __v_139: G = (__v_138 * __v_115);
-        let __v_140: G = (__v_137 + __v_139);
-        let __v_141: G = (__v_135 + __v_140);
-        let __v_142: G = (__v_133 + __v_141);
-        let __v_143: G = (__v_131 + __v_142);
-        let __v_144: G = (__v_129 + __v_143);
-        let __v_145: G = (__v_127 + __v_144);
-        let __v_146: G = (__v_108 + __v_145);
-        if (__v_146 != __v_107) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_107.as_canonical_u64(), msg: None });
-        }
-        let __v_147: G = G::from_u64(1);
-        let __v_148: G = G::from_u64(1);
-        let __v_149: G = (__v_148 - __v_125);
-        let __v_150: G = (__v_121 * __v_149);
-        let __v_151: G = (__v_147 - __v_150);
-        let __v_152: G = G::from_u64(1);
-        if (__v_151 != __v_152) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_152.as_canonical_u64(), msg: None });
-        }
-        let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes();
-        let __v_153: G = G::from_u8(__gb[0]);
-        let __v_154: G = G::from_u8(__gb[1]);
-        let __v_155: G = G::from_u8(__gb[2]);
-        let __v_156: G = G::from_u8(__gb[3]);
-        let __v_157: G = G::from_u8(__gb[4]);
-        let __v_158: G = G::from_u8(__gb[5]);
-        let __v_159: G = G::from_u8(__gb[6]);
-        let __v_160: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_153; let __vj = __v_154; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_155; let __vj = __v_156; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_157; let __vj = __v_158; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_159; let __vj = __v_160; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_161: G = G::from_u64(1020);
-        let __v_162: G = (__v_160 - __v_161);
-        let __v_163: G = (__v_159 + __v_162);
-        let __v_164: G = (__v_158 + __v_163);
-        let __v_165: G = (__v_157 + __v_164);
-        let __v_166: G = G::from_bool((__v_165 == G::ZERO));
-        let __v_167: G = (__v_155 + __v_156);
-        let __v_168: G = (__v_154 + __v_167);
-        let __v_169: G = (__v_153 + __v_168);
-        let __v_170: G = G::from_bool((__v_169 == G::ZERO));
-        let __v_171: G = G::from_u64(256);
-        let __v_172: G = (__v_171 * __v_154);
-        let __v_173: G = G::from_u64(65536);
-        let __v_174: G = (__v_173 * __v_155);
-        let __v_175: G = G::from_u64(16777216);
-        let __v_176: G = (__v_175 * __v_156);
-        let __v_177: G = G::from_u64(4294967296);
-        let __v_178: G = (__v_177 * __v_157);
-        let __v_179: G = G::from_u64(1099511627776);
-        let __v_180: G = (__v_179 * __v_158);
-        let __v_181: G = G::from_u64(281474976710656);
-        let __v_182: G = (__v_181 * __v_159);
-        let __v_183: G = G::from_u64(72057594037927936);
-        let __v_184: G = (__v_183 * __v_160);
-        let __v_185: G = (__v_182 + __v_184);
-        let __v_186: G = (__v_180 + __v_185);
-        let __v_187: G = (__v_178 + __v_186);
-        let __v_188: G = (__v_176 + __v_187);
-        let __v_189: G = (__v_174 + __v_188);
-        let __v_190: G = (__v_172 + __v_189);
-        let __v_191: G = (__v_153 + __v_190);
-        if (__v_191 != __v_42) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_191.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None });
-        }
-        let __v_192: G = G::from_u64(1);
-        let __v_193: G = G::from_u64(1);
-        let __v_194: G = (__v_193 - __v_170);
-        let __v_195: G = (__v_166 * __v_194);
-        let __v_196: G = (__v_192 - __v_195);
-        let __v_197: G = G::from_u64(1);
-        if (__v_196 != __v_197) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_196.as_canonical_u64(), rhs: __v_197.as_canonical_u64(), msg: None });
-        }
-        let __v_198: G = G::from_u64(1);
-        let __v_199: G = (__v_1 - __v_198);
-        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_55, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
-        let __v_200: G = __r_arr[0];
-        let __v_201: G = __r_arr[1];
-        let __v_202: G = __r_arr[2];
-        let __v_203: G = G::from_u64(0);
-        let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_205: G = G::from_u64(0);
-        let __v_206: G = G::from_u64(0);
-        let __v_207: G = G::from_u64(0);
-        let __v_208: G = G::from_u64(0);
-        let __v_209: G = G::from_u64(0);
-        let __v_210: G = G::from_u64(0);
-        let __v_211: G = G::from_u64(0);
-        let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_90] = [__v_204, __v_218, __v_202];
-        if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_91: usize = 1;
-const IN_91: usize = 1;
-const OUT_91: usize = 3;
-fn aiur_fn_91(
-  inp: [G; IN_91],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_91], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_91] = [__v_3, __v_4, __v_2];
-        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __v_4: G = __r_arr[1];
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __v_7: G = G::from_u64(1);
-        let __ret: [G; OUT_91] = [__v_7, __v_5, __v_6];
-        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_92: usize = 2;
-const IN_92: usize = 2;
-const OUT_92: usize = 2;
-fn aiur_fn_92(
-  inp: [G; IN_92],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_92], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_92] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        match __v_2.as_canonical_u64() {
-          65535u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(0);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_92] = [__v_11, __v_7];
-            if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_92] = [__v_10, __v_7];
-            if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_93: usize = 1;
-const IN_93: usize = 1;
-const OUT_93: usize = 9;
-fn aiur_fn_93(
-  inp: [G; IN_93],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_93], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __v_10: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    let __v_13: G = __r_arr[2];
-    let __v_14: G = __r_arr[3];
-    let __v_15: G = __r_arr[4];
-    let __v_16: G = __r_arr[5];
-    let __v_17: G = __r_arr[6];
-    let __v_18: G = __r_arr[7];
-    let __v_19: G = __r_arr[8];
-    let __v_20: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    let __v_23: G = __r_arr[2];
-    let __v_24: G = __r_arr[3];
-    let __v_25: G = __r_arr[4];
-    let __v_26: G = __r_arr[5];
-    let __v_27: G = __r_arr[6];
-    let __v_28: G = __r_arr[7];
-    let __v_29: G = __r_arr[8];
-    let __v_30: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_31: G = __r_arr[0];
-    let __v_32: G = __r_arr[1];
-    let __v_33: G = __r_arr[2];
-    let __v_34: G = __r_arr[3];
-    let __v_35: G = __r_arr[4];
-    let __v_36: G = __r_arr[5];
-    let __v_37: G = __r_arr[6];
-    let __v_38: G = __r_arr[7];
-    let __v_39: G = __r_arr[8];
-    let __v_40: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_41: G = __r_arr[0];
-    let __v_42: G = __r_arr[1];
-    let __v_43: G = __r_arr[2];
-    let __v_44: G = __r_arr[3];
-    let __v_45: G = __r_arr[4];
-    let __v_46: G = __r_arr[5];
-    let __v_47: G = __r_arr[6];
-    let __v_48: G = __r_arr[7];
-    let __v_49: G = __r_arr[8];
-    let __v_50: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __v_52: G = __r_arr[1];
-    let __v_53: G = __r_arr[2];
-    let __v_54: G = __r_arr[3];
-    let __v_55: G = __r_arr[4];
-    let __v_56: G = __r_arr[5];
-    let __v_57: G = __r_arr[6];
-    let __v_58: G = __r_arr[7];
-    let __v_59: G = __r_arr[8];
-    let __v_60: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_61: G = __r_arr[0];
-    let __v_62: G = __r_arr[1];
-    let __v_63: G = __r_arr[2];
-    let __v_64: G = __r_arr[3];
-    let __v_65: G = __r_arr[4];
-    let __v_66: G = __r_arr[5];
-    let __v_67: G = __r_arr[6];
-    let __v_68: G = __r_arr[7];
-    let __v_69: G = __r_arr[8];
-    let __v_70: G = __r_arr[9];
-    let __v_71: G = G::from_u64(0);
-    let __v_72: G = G::from_u64(0);
-    let __v_73: G = G::from_u64(0);
-    let __v_74: G = G::from_u64(0);
-    let __v_75: G = G::from_u64(0);
-    let __v_76: G = G::from_u64(0);
-    let __v_77: G = G::from_u64(0);
-    let __v_78: G = G::from_u64(1);
-    let __v_79: G = G::from_u64(1);
-    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_93] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70];
-    if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_94: usize = 1;
-const IN_94: usize = 1;
-const OUT_94: usize = 13;
-fn aiur_fn_94(
-  inp: [G; IN_94],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_94], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __v_10: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    let __v_13: G = __r_arr[2];
-    let __v_14: G = __r_arr[3];
-    let __v_15: G = __r_arr[4];
-    let __v_16: G = __r_arr[5];
-    let __v_17: G = __r_arr[6];
-    let __v_18: G = __r_arr[7];
-    let __v_19: G = __r_arr[8];
-    let __v_20: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    let __v_23: G = __r_arr[2];
-    let __v_24: G = __r_arr[3];
-    let __v_25: G = __r_arr[4];
-    let __v_26: G = __r_arr[5];
-    let __v_27: G = __r_arr[6];
-    let __v_28: G = __r_arr[7];
-    let __v_29: G = __r_arr[8];
-    let __v_30: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_31: G = __r_arr[0];
-    let __v_32: G = __r_arr[1];
-    let __v_33: G = __r_arr[2];
-    let __v_34: G = __r_arr[3];
-    let __v_35: G = __r_arr[4];
-    let __v_36: G = __r_arr[5];
-    let __v_37: G = __r_arr[6];
-    let __v_38: G = __r_arr[7];
-    let __v_39: G = __r_arr[8];
-    let __v_40: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_41: G = __r_arr[0];
-    let __v_42: G = __r_arr[1];
-    let __v_43: G = __r_arr[2];
-    let __v_44: G = __r_arr[3];
-    let __v_45: G = __r_arr[4];
-    let __v_46: G = __r_arr[5];
-    let __v_47: G = __r_arr[6];
-    let __v_48: G = __r_arr[7];
-    let __v_49: G = __r_arr[8];
-    let __v_50: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __v_52: G = __r_arr[1];
-    let __v_53: G = __r_arr[2];
-    let __v_54: G = __r_arr[3];
-    let __v_55: G = __r_arr[4];
-    let __v_56: G = __r_arr[5];
-    let __v_57: G = __r_arr[6];
-    let __v_58: G = __r_arr[7];
-    let __v_59: G = __r_arr[8];
-    let __v_60: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_61: G = __r_arr[0];
-    let __v_62: G = __r_arr[1];
-    let __v_63: G = __r_arr[2];
-    let __v_64: G = __r_arr[3];
-    let __v_65: G = __r_arr[4];
-    let __v_66: G = __r_arr[5];
-    let __v_67: G = __r_arr[6];
-    let __v_68: G = __r_arr[7];
-    let __v_69: G = __r_arr[8];
-    let __v_70: G = __r_arr[9];
-    let __v_71: G = G::from_u64(0);
-    let __v_72: G = G::from_u64(0);
-    let __v_73: G = G::from_u64(0);
-    let __v_74: G = G::from_u64(0);
-    let __v_75: G = G::from_u64(0);
-    let __v_76: G = G::from_u64(0);
-    let __v_77: G = G::from_u64(0);
-    let __v_78: G = G::from_u64(1);
-    let __v_79: G = G::from_u64(1);
-    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_88: G = __r_arr[0];
-    let __v_89: G = __r_arr[1];
-    let __v_90: G = __r_arr[2];
-    let __v_91: G = __r_arr[3];
-    let __v_92: G = __r_arr[4];
-    let __v_93: G = __r_arr[5];
-    let __v_94: G = __r_arr[6];
-    let __v_95: G = __r_arr[7];
-    let __v_96: G = __r_arr[8];
-    let __v_97: G = __r_arr[9];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_97, __v_88]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
-    let __v_98: G = __r_arr[0];
-    let __v_99: G = __r_arr[1];
-    let __v_100: G = __r_arr[2];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
-    let __v_101: G = __r_arr[0];
-    let __v_102: G = __r_arr[1];
-    let __v_103: G = __r_arr[2];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_103, __v_88]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
-    let __v_104: G = __r_arr[0];
-    let __v_105: G = __r_arr[1];
-    let __v_106: G = G::from_u64(0);
-    let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
-    let __v_108: G = __r_arr[0];
-    let __ret: [G; OUT_94] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_108, __v_98, __v_101, __v_102, __v_104, __v_105];
-    if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_95: usize = 5;
-const IN_95: usize = 5;
-const OUT_95: usize = 1;
-fn aiur_fn_95(
-  inp: [G; IN_95],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_95], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = G::from_u64(0);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = G::from_u64(0);
-    let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_95] = [__v_12];
-    if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_96: usize = 33;
-const IN_96: usize = 33;
-const OUT_96: usize = 1;
-fn aiur_fn_96(
-  inp: [G; IN_96],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-    let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-    let __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-    let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-    let __v_38: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-    let __v_39: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-    let __v_40: G = __r_arr[0];
-    let __ret: [G; OUT_96] = [__v_40];
-    if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_97: usize = 32;
-const IN_97: usize = 32;
-const OUT_97: usize = 32;
-fn aiur_fn_97(
-  inp: [G; IN_97],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __ret: [G; OUT_97] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31];
-    if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_98: usize = 2;
-const IN_98: usize = 2;
-const OUT_98: usize = 1;
-fn aiur_fn_98(
-  inp: [G; IN_98],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_98], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(103);
-    let __v_3: G = G::from_u64(230);
-    let __v_4: G = G::from_u64(9);
-    let __v_5: G = G::from_u64(106);
-    let __v_6: G = G::from_u64(133);
-    let __v_7: G = G::from_u64(174);
-    let __v_8: G = G::from_u64(103);
-    let __v_9: G = G::from_u64(187);
-    let __v_10: G = G::from_u64(114);
-    let __v_11: G = G::from_u64(243);
-    let __v_12: G = G::from_u64(110);
-    let __v_13: G = G::from_u64(60);
-    let __v_14: G = G::from_u64(58);
-    let __v_15: G = G::from_u64(245);
-    let __v_16: G = G::from_u64(79);
-    let __v_17: G = G::from_u64(165);
-    let __v_18: G = G::from_u64(127);
-    let __v_19: G = G::from_u64(82);
-    let __v_20: G = G::from_u64(14);
-    let __v_21: G = G::from_u64(81);
-    let __v_22: G = G::from_u64(140);
-    let __v_23: G = G::from_u64(104);
-    let __v_24: G = G::from_u64(5);
-    let __v_25: G = G::from_u64(155);
-    let __v_26: G = G::from_u64(171);
-    let __v_27: G = G::from_u64(217);
-    let __v_28: G = G::from_u64(131);
-    let __v_29: G = G::from_u64(31);
-    let __v_30: G = G::from_u64(25);
-    let __v_31: G = G::from_u64(205);
-    let __v_32: G = G::from_u64(224);
-    let __v_33: G = G::from_u64(91);
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-    let __v_34: G = __loaded[0];
-    let __v_35: G = __loaded[1];
-    let __v_36: G = __loaded[2];
-    let __v_37: G = __loaded[3];
-    let __v_38: G = __loaded[4];
-    let __v_39: G = __loaded[5];
-    let __v_40: G = __loaded[6];
-    let __v_41: G = __loaded[7];
-    let __v_42: G = __loaded[8];
-    let __v_43: G = __loaded[9];
-    let __v_44: G = __loaded[10];
-    let __v_45: G = __loaded[11];
-    let __v_46: G = __loaded[12];
-    let __v_47: G = __loaded[13];
-    let __v_48: G = __loaded[14];
-    let __v_49: G = __loaded[15];
-    let __v_50: G = __loaded[16];
-    let __v_51: G = __loaded[17];
-    let __v_52: G = __loaded[18];
-    let __v_53: G = __loaded[19];
-    let __v_54: G = __loaded[20];
-    let __v_55: G = __loaded[21];
-    let __v_56: G = __loaded[22];
-    let __v_57: G = __loaded[23];
-    let __v_58: G = __loaded[24];
-    let __v_59: G = __loaded[25];
-    let __v_60: G = __loaded[26];
-    let __v_61: G = __loaded[27];
-    let __v_62: G = __loaded[28];
-    let __v_63: G = __loaded[29];
-    let __v_64: G = __loaded[30];
-    let __v_65: G = __loaded[31];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-    let __v_66: G = __loaded[0];
-    let __v_67: G = __loaded[1];
-    let __v_68: G = __loaded[2];
-    let __v_69: G = __loaded[3];
-    let __v_70: G = __loaded[4];
-    let __v_71: G = __loaded[5];
-    let __v_72: G = __loaded[6];
-    let __v_73: G = __loaded[7];
-    let __v_74: G = __loaded[8];
-    let __v_75: G = __loaded[9];
-    let __v_76: G = __loaded[10];
-    let __v_77: G = __loaded[11];
-    let __v_78: G = __loaded[12];
-    let __v_79: G = __loaded[13];
-    let __v_80: G = __loaded[14];
-    let __v_81: G = __loaded[15];
-    let __v_82: G = __loaded[16];
-    let __v_83: G = __loaded[17];
-    let __v_84: G = __loaded[18];
-    let __v_85: G = __loaded[19];
-    let __v_86: G = __loaded[20];
-    let __v_87: G = __loaded[21];
-    let __v_88: G = __loaded[22];
-    let __v_89: G = __loaded[23];
-    let __v_90: G = __loaded[24];
-    let __v_91: G = __loaded[25];
-    let __v_92: G = __loaded[26];
-    let __v_93: G = __loaded[27];
-    let __v_94: G = __loaded[28];
-    let __v_95: G = __loaded[29];
-    let __v_96: G = __loaded[30];
-    let __v_97: G = __loaded[31];
-    let __v_98: G = G::from_u64(0);
-    let __v_99: G = G::from_u64(0);
-    let __v_100: G = G::from_u64(0);
-    let __v_101: G = G::from_u64(0);
-    let __v_102: G = G::from_u64(0);
-    let __v_103: G = G::from_u64(0);
-    let __v_104: G = G::from_u64(0);
-    let __v_105: G = G::from_u64(0);
-    let __v_106: G = G::from_u64(64);
-    let __v_107: G = G::from_u64(11);
-    let __v_108: G = G::from_u64(103);
-    let __v_109: G = G::from_u64(230);
-    let __v_110: G = G::from_u64(9);
-    let __v_111: G = G::from_u64(106);
-    let __v_112: G = G::from_u64(133);
-    let __v_113: G = G::from_u64(174);
-    let __v_114: G = G::from_u64(103);
-    let __v_115: G = G::from_u64(187);
-    let __v_116: G = G::from_u64(114);
-    let __v_117: G = G::from_u64(243);
-    let __v_118: G = G::from_u64(110);
-    let __v_119: G = G::from_u64(60);
-    let __v_120: G = G::from_u64(58);
-    let __v_121: G = G::from_u64(245);
-    let __v_122: G = G::from_u64(79);
-    let __v_123: G = G::from_u64(165);
-    let __v_124: G = G::from_u64(0);
-    let __v_125: G = G::from_u64(0);
-    let __v_126: G = G::from_u64(0);
-    let __v_127: G = G::from_u64(0);
-    let __v_128: G = G::from_u64(0);
-    let __v_129: G = G::from_u64(0);
-    let __v_130: G = G::from_u64(0);
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_130, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_124, __v_125, __v_126, __v_107, __v_127, __v_128, __v_129, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-    let __v_131: G = __r_arr[0];
-    let __v_132: G = __r_arr[1];
-    let __v_133: G = __r_arr[2];
-    let __v_134: G = __r_arr[3];
-    let __v_135: G = __r_arr[4];
-    let __v_136: G = __r_arr[5];
-    let __v_137: G = __r_arr[6];
-    let __v_138: G = __r_arr[7];
-    let __v_139: G = __r_arr[8];
-    let __v_140: G = __r_arr[9];
-    let __v_141: G = __r_arr[10];
-    let __v_142: G = __r_arr[11];
-    let __v_143: G = __r_arr[12];
-    let __v_144: G = __r_arr[13];
-    let __v_145: G = __r_arr[14];
-    let __v_146: G = __r_arr[15];
-    let __v_147: G = __r_arr[16];
-    let __v_148: G = __r_arr[17];
-    let __v_149: G = __r_arr[18];
-    let __v_150: G = __r_arr[19];
-    let __v_151: G = __r_arr[20];
-    let __v_152: G = __r_arr[21];
-    let __v_153: G = __r_arr[22];
-    let __v_154: G = __r_arr[23];
-    let __v_155: G = __r_arr[24];
-    let __v_156: G = __r_arr[25];
-    let __v_157: G = __r_arr[26];
-    let __v_158: G = __r_arr[27];
-    let __v_159: G = __r_arr[28];
-    let __v_160: G = __r_arr[29];
-    let __v_161: G = __r_arr[30];
-    let __v_162: G = __r_arr[31];
-    let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_98] = [__v_163];
-    if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_99: usize = 3;
-const IN_99: usize = 3;
-const OUT_99: usize = 1;
-fn aiur_fn_99(
-  inp: [G; IN_99],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_99] = [__v_3];
-        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_99] = [__v_3];
-        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_100: usize = 2;
-const IN_100: usize = 2;
-const OUT_100: usize = 1;
-fn aiur_fn_100(
-  inp: [G; IN_100],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_100] = [__v_5];
-        if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = (__v_3 - __v_1);
-        let __v_6: G = G::from_bool((__v_5 == G::ZERO));
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_100] = [__v_7];
-            if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_100] = [__v_7];
-            if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_101: usize = 3;
-const IN_101: usize = 3;
-const OUT_101: usize = 1;
-fn aiur_fn_101(
-  inp: [G; IN_101],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_101], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_101] = [__v_8];
-        if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          0u64 => {
-            let __v_9: G = (__v_7 - __v_2);
-            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
-            match __v_10.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_101] = [__v_11];
-                if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-                let __v_11: G = __loaded[0];
-                let __v_12: G = __loaded[1];
-                let __v_13: G = __loaded[2];
-                let __v_14: G = __loaded[3];
-                let __v_15: G = __loaded[4];
-                let __v_16: G = __loaded[5];
-                let __v_17: G = __loaded[6];
-                let __v_18: G = __loaded[7];
-                let __v_19: G = __loaded[8];
-                let __v_20: G = __loaded[9];
-                match __v_11.as_canonical_u64() {
-                  1u64 => {
-                    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
-                    let __v_21: G = __r_arr[0];
-                    let __ret: [G; OUT_101] = [__v_21];
-                    if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __v_21: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
-                    let __v_22: G = __r_arr[0];
-                    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_101] = [__v_23];
-                    if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                    return Ok(__ret);
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_102: usize = 2;
-const IN_102: usize = 2;
-const OUT_102: usize = 11;
-fn aiur_fn_102(
-  inp: [G; IN_102],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_12: G = G::from_u64(256);
-        let __v_13: G = (__v_12 * __v_4);
-        let __v_14: G = G::from_u64(65536);
-        let __v_15: G = (__v_14 * __v_5);
-        let __v_16: G = G::from_u64(16777216);
-        let __v_17: G = (__v_16 * __v_6);
-        let __v_18: G = G::from_u64(4294967296);
-        let __v_19: G = (__v_18 * __v_7);
-        let __v_20: G = G::from_u64(1099511627776);
-        let __v_21: G = (__v_20 * __v_8);
-        let __v_22: G = G::from_u64(281474976710656);
-        let __v_23: G = (__v_22 * __v_9);
-        let __v_24: G = G::from_u64(72057594037927936);
-        let __v_25: G = (__v_24 * __v_10);
-        let __v_26: G = (__v_23 + __v_25);
-        let __v_27: G = (__v_21 + __v_26);
-        let __v_28: G = (__v_19 + __v_27);
-        let __v_29: G = (__v_17 + __v_28);
-        let __v_30: G = (__v_15 + __v_29);
-        let __v_31: G = (__v_13 + __v_30);
-        let __v_32: G = (__v_3 + __v_31);
-        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
-        let __v_33: G = G::from_u8(__gb[0]);
-        let __v_34: G = G::from_u8(__gb[1]);
-        let __v_35: G = G::from_u8(__gb[2]);
-        let __v_36: G = G::from_u8(__gb[3]);
-        let __v_37: G = G::from_u8(__gb[4]);
-        let __v_38: G = G::from_u8(__gb[5]);
-        let __v_39: G = G::from_u8(__gb[6]);
-        let __v_40: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_41: G = G::from_u64(1020);
-        let __v_42: G = (__v_40 - __v_41);
-        let __v_43: G = (__v_39 + __v_42);
-        let __v_44: G = (__v_38 + __v_43);
-        let __v_45: G = (__v_37 + __v_44);
-        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
-        let __v_47: G = (__v_35 + __v_36);
-        let __v_48: G = (__v_34 + __v_47);
-        let __v_49: G = (__v_33 + __v_48);
-        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
-        let __v_51: G = G::from_u64(256);
-        let __v_52: G = (__v_51 * __v_34);
-        let __v_53: G = G::from_u64(65536);
-        let __v_54: G = (__v_53 * __v_35);
-        let __v_55: G = G::from_u64(16777216);
-        let __v_56: G = (__v_55 * __v_36);
-        let __v_57: G = G::from_u64(4294967296);
-        let __v_58: G = (__v_57 * __v_37);
-        let __v_59: G = G::from_u64(1099511627776);
-        let __v_60: G = (__v_59 * __v_38);
-        let __v_61: G = G::from_u64(281474976710656);
-        let __v_62: G = (__v_61 * __v_39);
-        let __v_63: G = G::from_u64(72057594037927936);
-        let __v_64: G = (__v_63 * __v_40);
-        let __v_65: G = (__v_62 + __v_64);
-        let __v_66: G = (__v_60 + __v_65);
-        let __v_67: G = (__v_58 + __v_66);
-        let __v_68: G = (__v_56 + __v_67);
-        let __v_69: G = (__v_54 + __v_68);
-        let __v_70: G = (__v_52 + __v_69);
-        let __v_71: G = (__v_33 + __v_70);
-        if (__v_71 != __v_32) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
-        }
-        let __v_72: G = G::from_u64(1);
-        let __v_73: G = G::from_u64(1);
-        let __v_74: G = (__v_73 - __v_50);
-        let __v_75: G = (__v_46 * __v_74);
-        let __v_76: G = (__v_72 - __v_75);
-        let __v_77: G = G::from_u64(1);
-        if (__v_76 != __v_77) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
-        }
-        let __v_78: G = G::from_u64(1);
-        let __ret: [G; OUT_102] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_15: G = G::from_u64(0);
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = G::from_u64(0);
-            let __v_18: G = G::from_u64(0);
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = G::from_u64(0);
-            let __v_21: G = G::from_u64(0);
-            let __v_22: G = G::from_u64(0);
-            let __v_23: G = G::from_u64(0);
-            let __ret: [G; OUT_102] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
-            if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __v_16: G = __r_arr[1];
-            let __v_17: G = __r_arr[2];
-            let __v_18: G = __r_arr[3];
-            let __v_19: G = __r_arr[4];
-            let __v_20: G = __r_arr[5];
-            let __v_21: G = __r_arr[6];
-            let __v_22: G = __r_arr[7];
-            let __v_23: G = __r_arr[8];
-            let __v_24: G = __r_arr[9];
-            let __v_25: G = __r_arr[10];
-            let __ret: [G; OUT_102] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-            if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_103: usize = 6;
-const IN_103: usize = 6;
-const OUT_103: usize = 1;
-fn aiur_fn_103(
-  inp: [G; IN_103],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    let __v_8: G = __r_arr[2];
-    let __v_9: G = __r_arr[3];
-    let __v_10: G = __r_arr[4];
-    let __v_11: G = __r_arr[5];
-    let __v_12: G = __r_arr[6];
-    let __v_13: G = __r_arr[7];
-    let __v_14: G = __r_arr[8];
-    let __v_15: G = __r_arr[9];
-    let __v_16: G = __r_arr[10];
-    match __v_16.as_canonical_u64() {
-      0u64 => {
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_17: G = __loaded[0];
-        let __v_18: G = __loaded[1];
-        let __v_19: G = __loaded[2];
-        let __v_20: G = __loaded[3];
-        let __v_21: G = __loaded[4];
-        let __v_22: G = __loaded[5];
-        let __v_23: G = __loaded[6];
-        let __v_24: G = __loaded[7];
-        match __v_17.as_canonical_u64() {
-          0u64 => {
-            match __v_18.as_canonical_u64() {
-              0u64 => {
-                match __v_19.as_canonical_u64() {
-                  0u64 => {
-                    match __v_20.as_canonical_u64() {
-                      0u64 => {
-                        match __v_21.as_canonical_u64() {
-                          0u64 => {
-                            match __v_22.as_canonical_u64() {
-                              0u64 => {
-                                match __v_23.as_canonical_u64() {
-                                  0u64 => {
-                                    match __v_24.as_canonical_u64() {
-                                      0u64 => {
-                                        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-                                        let __v_25: G = __loaded[0];
-                                        let __v_26: G = __loaded[1];
-                                        let __v_27: G = __loaded[2];
-                                        let __v_28: G = __loaded[3];
-                                        let __v_29: G = __loaded[4];
-                                        let __v_30: G = __loaded[5];
-                                        let __v_31: G = __loaded[6];
-                                        let __v_32: G = __loaded[7];
-                                        let __v_33: G = __loaded[8];
-                                        let __v_34: G = __loaded[9];
-                                        let __v_35: G = __loaded[10];
-                                        let __v_36: G = __loaded[11];
-                                        let __v_37: G = __loaded[12];
-                                        let __v_38: G = __loaded[13];
-                                        let __v_39: G = __loaded[14];
-                                        let __v_40: G = __loaded[15];
-                                        let __v_41: G = __loaded[16];
-                                        let __v_42: G = __loaded[17];
-                                        let __v_43: G = __loaded[18];
-                                        let __v_44: G = __loaded[19];
-                                        let __v_45: G = __loaded[20];
-                                        let __v_46: G = __loaded[21];
-                                        let __v_47: G = __loaded[22];
-                                        let __v_48: G = __loaded[23];
-                                        let __v_49: G = __loaded[24];
-                                        let __v_50: G = __loaded[25];
-                                        let __v_51: G = __loaded[26];
-                                        let __v_52: G = __loaded[27];
-                                        let __v_53: G = __loaded[28];
-                                        let __v_54: G = __loaded[29];
-                                        let __v_55: G = __loaded[30];
-                                        let __v_56: G = __loaded[31];
-                                        let __v_57: G = G::from_u64(0);
-                                        let __v_58: G = G::from_u64(0);
-                                        let __v_59: G = G::from_u64(0);
-                                        let __v_60: G = G::from_u64(0);
-                                        let __v_61: G = G::from_u64(0);
-                                        let __v_62: G = G::from_u64(0);
-                                        let __v_63: G = G::from_u64(0);
-                                        let __v_64: G = G::from_u64(0);
-                                        let __v_65: G = G::from_u64(0);
-                                        let __v_66: G = G::from_u64(0);
-                                        let __v_67: G = G::from_u64(0);
-                                        let __v_68: G = G::from_u64(0);
-                                        let __v_69: G = G::from_u64(0);
-                                        let __v_70: G = G::from_u64(0);
-                                        let __v_71: G = G::from_u64(0);
-                                        let __v_72: G = G::from_u64(0);
-                                        let __v_73: G = G::from_u64(0);
-                                        let __v_74: G = G::from_u64(0);
-                                        let __v_75: G = G::from_u64(0);
-                                        let __v_76: G = G::from_u64(0);
-                                        let __v_77: G = G::from_u64(0);
-                                        let __v_78: G = G::from_u64(0);
-                                        let __v_79: G = G::from_u64(0);
-                                        let __v_80: G = G::from_u64(0);
-                                        let __v_81: G = G::from_u64(0);
-                                        let __v_82: G = G::from_u64(0);
-                                        let __v_83: G = G::from_u64(0);
-                                        let __v_84: G = G::from_u64(0);
-                                        let __v_85: G = G::from_u64(0);
-                                        let __v_86: G = G::from_u64(0);
-                                        let __v_87: G = G::from_u64(0);
-                                        let __v_88: G = G::from_u64(0);
-                                        let __v_89: G = G::from_u64(0);
-                                        let __v_90: G = G::from_u64(0);
-                                        let __v_91: G = G::from_u64(0);
-                                        let __v_92: G = G::from_u64(0);
-                                        let __v_93: G = G::from_u64(0);
-                                        let __v_94: G = G::from_u64(0);
-                                        let __v_95: G = G::from_u64(0);
-                                        let __v_96: G = G::from_u64(0);
-                                        let __v_97: G = G::from_u64(0);
-                                        let __v_98: G = G::from_u64(0);
-                                        let __v_99: G = G::from_u64(0);
-                                        let __v_100: G = G::from_u64(0);
-                                        let __v_101: G = G::from_u64(0);
-                                        let __v_102: G = G::from_u64(0);
-                                        let __v_103: G = G::from_u64(0);
-                                        let __v_104: G = G::from_u64(0);
-                                        let __v_105: G = G::from_u64(0);
-                                        let __v_106: G = G::from_u64(0);
-                                        let __v_107: G = G::from_u64(0);
-                                        let __v_108: G = G::from_u64(0);
-                                        let __v_109: G = G::from_u64(0);
-                                        let __v_110: G = G::from_u64(0);
-                                        let __v_111: G = G::from_u64(0);
-                                        let __v_112: G = G::from_u64(0);
-                                        let __v_113: G = G::from_u64(0);
-                                        let __v_114: G = G::from_u64(0);
-                                        let __v_115: G = G::from_u64(0);
-                                        let __v_116: G = G::from_u64(0);
-                                        let __v_117: G = G::from_u64(0);
-                                        let __v_118: G = G::from_u64(0);
-                                        let __v_119: G = G::from_u64(0);
-                                        let __v_120: G = G::from_u64(0);
-                                        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-                                        let __v_121: G = __loaded[0];
-                                        let __v_122: G = __loaded[1];
-                                        let __v_123: G = __loaded[2];
-                                        let __v_124: G = __loaded[3];
-                                        let __v_125: G = __loaded[4];
-                                        let __v_126: G = __loaded[5];
-                                        let __v_127: G = __loaded[6];
-                                        let __v_128: G = __loaded[7];
-                                        let __v_129: G = G::from_u64(0);
-                                        let __v_130: G = G::from_u64(11);
-                                        let __v_131: G = G::from_u64(103);
-                                        let __v_132: G = G::from_u64(230);
-                                        let __v_133: G = G::from_u64(9);
-                                        let __v_134: G = G::from_u64(106);
-                                        let __v_135: G = G::from_u64(133);
-                                        let __v_136: G = G::from_u64(174);
-                                        let __v_137: G = G::from_u64(103);
-                                        let __v_138: G = G::from_u64(187);
-                                        let __v_139: G = G::from_u64(114);
-                                        let __v_140: G = G::from_u64(243);
-                                        let __v_141: G = G::from_u64(110);
-                                        let __v_142: G = G::from_u64(60);
-                                        let __v_143: G = G::from_u64(58);
-                                        let __v_144: G = G::from_u64(245);
-                                        let __v_145: G = G::from_u64(79);
-                                        let __v_146: G = G::from_u64(165);
-                                        let __v_147: G = G::from_u64(0);
-                                        let __v_148: G = G::from_u64(0);
-                                        let __v_149: G = G::from_u64(0);
-                                        let __v_150: G = G::from_u64(0);
-                                        let __v_151: G = G::from_u64(0);
-                                        let __v_152: G = G::from_u64(0);
-                                        let __v_153: G = G::from_u64(0);
-                                        let __v_154: G = G::from_u64(0);
-                                        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_154, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_147, __v_148, __v_149, __v_130, __v_150, __v_151, __v_152, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-                                        let __v_155: G = __r_arr[0];
-                                        let __v_156: G = __r_arr[1];
-                                        let __v_157: G = __r_arr[2];
-                                        let __v_158: G = __r_arr[3];
-                                        let __v_159: G = __r_arr[4];
-                                        let __v_160: G = __r_arr[5];
-                                        let __v_161: G = __r_arr[6];
-                                        let __v_162: G = __r_arr[7];
-                                        let __v_163: G = __r_arr[8];
-                                        let __v_164: G = __r_arr[9];
-                                        let __v_165: G = __r_arr[10];
-                                        let __v_166: G = __r_arr[11];
-                                        let __v_167: G = __r_arr[12];
-                                        let __v_168: G = __r_arr[13];
-                                        let __v_169: G = __r_arr[14];
-                                        let __v_170: G = __r_arr[15];
-                                        let __v_171: G = __r_arr[16];
-                                        let __v_172: G = __r_arr[17];
-                                        let __v_173: G = __r_arr[18];
-                                        let __v_174: G = __r_arr[19];
-                                        let __v_175: G = __r_arr[20];
-                                        let __v_176: G = __r_arr[21];
-                                        let __v_177: G = __r_arr[22];
-                                        let __v_178: G = __r_arr[23];
-                                        let __v_179: G = __r_arr[24];
-                                        let __v_180: G = __r_arr[25];
-                                        let __v_181: G = __r_arr[26];
-                                        let __v_182: G = __r_arr[27];
-                                        let __v_183: G = __r_arr[28];
-                                        let __v_184: G = __r_arr[29];
-                                        let __v_185: G = __r_arr[30];
-                                        let __v_186: G = __r_arr[31];
-                                        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_103] = [__v_187];
-                                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                        return Ok(__ret);
-                                      },
-                                      _ => {
-                                        let __ret: [G; OUT_103] = [__v_5];
-                                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                        return Ok(__ret);
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    let __ret: [G; OUT_103] = [__v_5];
-                                    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                    return Ok(__ret);
-                                  },
-                                }
-                              },
-                              _ => {
-                                let __ret: [G; OUT_103] = [__v_5];
-                                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                return Ok(__ret);
-                              },
-                            }
-                          },
-                          _ => {
-                            let __ret: [G; OUT_103] = [__v_5];
-                            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        let __ret: [G; OUT_103] = [__v_5];
-                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    let __ret: [G; OUT_103] = [__v_5];
-                    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __ret: [G; OUT_103] = [__v_5];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __ret: [G; OUT_103] = [__v_5];
-            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = __r_arr[1];
-        let __v_19: G = __r_arr[2];
-        let __v_20: G = __r_arr[3];
-        let __v_21: G = __r_arr[4];
-        let __v_22: G = __r_arr[5];
-        let __v_23: G = __r_arr[6];
-        let __v_24: G = __r_arr[7];
-        let __v_25: G = __r_arr[8];
-        let __v_26: G = __r_arr[9];
-        let __v_27: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        let __v_29: G = __r_arr[1];
-        let __v_30: G = __r_arr[2];
-        let __v_31: G = __r_arr[3];
-        let __v_32: G = __r_arr[4];
-        let __v_33: G = __r_arr[5];
-        let __v_34: G = __r_arr[6];
-        let __v_35: G = __r_arr[7];
-        let __v_36: G = __r_arr[8];
-        let __v_37: G = __r_arr[9];
-        let __v_38: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-        let __v_39: G = __r_arr[0];
-        let __v_40: G = __r_arr[1];
-        let __v_41: G = __r_arr[2];
-        let __v_42: G = __r_arr[3];
-        let __v_43: G = __r_arr[4];
-        let __v_44: G = __r_arr[5];
-        let __v_45: G = __r_arr[6];
-        let __v_46: G = __r_arr[7];
-        let __v_47: G = __r_arr[8];
-        let __v_48: G = __r_arr[9];
-        let __v_49: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-        let __v_50: G = __r_arr[0];
-        let __v_51: G = __r_arr[1];
-        let __v_52: G = __r_arr[2];
-        let __v_53: G = __r_arr[3];
-        let __v_54: G = __r_arr[4];
-        let __v_55: G = __r_arr[5];
-        let __v_56: G = __r_arr[6];
-        let __v_57: G = __r_arr[7];
-        let __v_58: G = __r_arr[8];
-        let __v_59: G = __r_arr[9];
-        let __v_60: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-        let __v_61: G = __r_arr[0];
-        let __v_62: G = __r_arr[1];
-        let __v_63: G = __r_arr[2];
-        let __v_64: G = __r_arr[3];
-        let __v_65: G = __r_arr[4];
-        let __v_66: G = __r_arr[5];
-        let __v_67: G = __r_arr[6];
-        let __v_68: G = __r_arr[7];
-        let __v_69: G = __r_arr[8];
-        let __v_70: G = __r_arr[9];
-        let __v_71: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-        let __v_72: G = __r_arr[0];
-        let __v_73: G = __r_arr[1];
-        let __v_74: G = __r_arr[2];
-        let __v_75: G = __r_arr[3];
-        let __v_76: G = __r_arr[4];
-        let __v_77: G = __r_arr[5];
-        let __v_78: G = __r_arr[6];
-        let __v_79: G = __r_arr[7];
-        let __v_80: G = __r_arr[8];
-        let __v_81: G = __r_arr[9];
-        let __v_82: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
-        let __v_83: G = __r_arr[0];
-        let __v_84: G = __r_arr[1];
-        let __v_85: G = __r_arr[2];
-        let __v_86: G = __r_arr[3];
-        let __v_87: G = __r_arr[4];
-        let __v_88: G = __r_arr[5];
-        let __v_89: G = __r_arr[6];
-        let __v_90: G = __r_arr[7];
-        let __v_91: G = __r_arr[8];
-        let __v_92: G = __r_arr[9];
-        let __v_93: G = __r_arr[10];
-        let __v_94: G = G::from_u64(8);
-        let __v_95: G = (__v_82 + __v_93);
-        let __v_96: G = (__v_71 + __v_95);
-        let __v_97: G = (__v_60 + __v_96);
-        let __v_98: G = (__v_49 + __v_97);
-        let __v_99: G = (__v_38 + __v_98);
-        let __v_100: G = (__v_27 + __v_99);
-        let __v_101: G = (__v_16 + __v_100);
-        let __v_102: G = (__v_94 * __v_101);
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_103: G = __loaded[0];
-        let __v_104: G = __loaded[1];
-        let __v_105: G = __loaded[2];
-        let __v_106: G = __loaded[3];
-        let __v_107: G = __loaded[4];
-        let __v_108: G = __loaded[5];
-        let __v_109: G = __loaded[6];
-        let __v_110: G = __loaded[7];
-        let __v_111: G = __loaded[8];
-        let __v_112: G = __loaded[9];
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() {
-  1u64 => {
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_113: G = __loaded[0];
-    let __v_114: G = __loaded[1];
-    let __v_115: G = __loaded[2];
-    match __v_113.as_canonical_u64() {
-      1u64 => {
-        let __v_116: G = G::from_u64(1);
-        break '__mc_0 [__v_116];
-      },
-      _ => {
-        let __v_116: G = G::from_u64(0);
-        break '__mc_0 [__v_116];
-      },
-    }
-  },
-  _ => {
-    let __v_113: G = G::from_u64(0);
-    break '__mc_0 [__v_113];
-  },
-}
- };
-        let __v_113: G = __mc_out___mc_0[0];
-        let __v_114: G = G::from_u64(15);
-        let __v_115: G = (__v_2 - __v_114);
-        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
-        let __v_117: G = G::from_bool((__v_2 == G::ZERO));
-        let __v_118: G = (__v_113 * __v_116);
-        let __v_119: G = (__v_116 - __v_118);
-        let __v_120: G = (__v_113 + __v_119);
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_121: G = __loaded[0];
-        let __v_122: G = __loaded[1];
-        let __v_123: G = __loaded[2];
-        let __v_124: G = __loaded[3];
-        let __v_125: G = __loaded[4];
-        let __v_126: G = __loaded[5];
-        let __v_127: G = __loaded[6];
-        let __v_128: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_129: G = __r_arr[0];
-        let __v_130: G = (__v_113 * __v_129);
-        let __v_131: G = G::from_u64(2);
-        let __v_132: G = (__v_131 * __v_120);
-        let __v_133: G = G::from_u64(8);
-        let __v_134: G = (__v_133 * __v_130);
-        let __v_135: G = (__v_132 + __v_134);
-        let __v_136: G = (__v_117 + __v_135);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_137: G = __loaded[0];
-        let __v_138: G = __loaded[1];
-        let __v_139: G = __loaded[2];
-        let __v_140: G = __loaded[3];
-        let __v_141: G = __loaded[4];
-        let __v_142: G = __loaded[5];
-        let __v_143: G = __loaded[6];
-        let __v_144: G = __loaded[7];
-        let __v_145: G = __loaded[8];
-        let __v_146: G = __loaded[9];
-        let __v_147: G = __loaded[10];
-        let __v_148: G = __loaded[11];
-        let __v_149: G = __loaded[12];
-        let __v_150: G = __loaded[13];
-        let __v_151: G = __loaded[14];
-        let __v_152: G = __loaded[15];
-        let __v_153: G = __loaded[16];
-        let __v_154: G = __loaded[17];
-        let __v_155: G = __loaded[18];
-        let __v_156: G = __loaded[19];
-        let __v_157: G = __loaded[20];
-        let __v_158: G = __loaded[21];
-        let __v_159: G = __loaded[22];
-        let __v_160: G = __loaded[23];
-        let __v_161: G = __loaded[24];
-        let __v_162: G = __loaded[25];
-        let __v_163: G = __loaded[26];
-        let __v_164: G = __loaded[27];
-        let __v_165: G = __loaded[28];
-        let __v_166: G = __loaded[29];
-        let __v_167: G = __loaded[30];
-        let __v_168: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_169: G = __loaded[0];
-        let __v_170: G = __loaded[1];
-        let __v_171: G = __loaded[2];
-        let __v_172: G = __loaded[3];
-        let __v_173: G = __loaded[4];
-        let __v_174: G = __loaded[5];
-        let __v_175: G = __loaded[6];
-        let __v_176: G = __loaded[7];
-        let __v_177: G = G::from_u64(103);
-        let __v_178: G = G::from_u64(230);
-        let __v_179: G = G::from_u64(9);
-        let __v_180: G = G::from_u64(106);
-        let __v_181: G = G::from_u64(133);
-        let __v_182: G = G::from_u64(174);
-        let __v_183: G = G::from_u64(103);
-        let __v_184: G = G::from_u64(187);
-        let __v_185: G = G::from_u64(114);
-        let __v_186: G = G::from_u64(243);
-        let __v_187: G = G::from_u64(110);
-        let __v_188: G = G::from_u64(60);
-        let __v_189: G = G::from_u64(58);
-        let __v_190: G = G::from_u64(245);
-        let __v_191: G = G::from_u64(79);
-        let __v_192: G = G::from_u64(165);
-        let __v_193: G = G::from_u64(0);
-        let __v_194: G = G::from_u64(0);
-        let __v_195: G = G::from_u64(0);
-        let __v_196: G = G::from_u64(0);
-        let __v_197: G = G::from_u64(0);
-        let __v_198: G = G::from_u64(0);
-        let __v_199: G = G::from_u64(0);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_199, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_193, __v_194, __v_195, __v_136, __v_196, __v_197, __v_198, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
-        let __v_200: G = __r_arr[0];
-        let __v_201: G = __r_arr[1];
-        let __v_202: G = __r_arr[2];
-        let __v_203: G = __r_arr[3];
-        let __v_204: G = __r_arr[4];
-        let __v_205: G = __r_arr[5];
-        let __v_206: G = __r_arr[6];
-        let __v_207: G = __r_arr[7];
-        let __v_208: G = __r_arr[8];
-        let __v_209: G = __r_arr[9];
-        let __v_210: G = __r_arr[10];
-        let __v_211: G = __r_arr[11];
-        let __v_212: G = __r_arr[12];
-        let __v_213: G = __r_arr[13];
-        let __v_214: G = __r_arr[14];
-        let __v_215: G = __r_arr[15];
-        let __v_216: G = __r_arr[16];
-        let __v_217: G = __r_arr[17];
-        let __v_218: G = __r_arr[18];
-        let __v_219: G = __r_arr[19];
-        let __v_220: G = __r_arr[20];
-        let __v_221: G = __r_arr[21];
-        let __v_222: G = __r_arr[22];
-        let __v_223: G = __r_arr[23];
-        let __v_224: G = __r_arr[24];
-        let __v_225: G = __r_arr[25];
-        let __v_226: G = __r_arr[26];
-        let __v_227: G = __r_arr[27];
-        let __v_228: G = __r_arr[28];
-        let __v_229: G = __r_arr[29];
-        let __v_230: G = __r_arr[30];
-        let __v_231: G = __r_arr[31];
-        match __v_113.as_canonical_u64() {
-          1u64 => {
-            let __v_232: G = G::from_u64(0);
-            let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_103] = [__v_233];
-            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            match __v_116.as_canonical_u64() {
-              1u64 => {
-                let __v_232: G = G::from_u64(103);
-                let __v_233: G = G::from_u64(230);
-                let __v_234: G = G::from_u64(9);
-                let __v_235: G = G::from_u64(106);
-                let __v_236: G = G::from_u64(133);
-                let __v_237: G = G::from_u64(174);
-                let __v_238: G = G::from_u64(103);
-                let __v_239: G = G::from_u64(187);
-                let __v_240: G = G::from_u64(114);
-                let __v_241: G = G::from_u64(243);
-                let __v_242: G = G::from_u64(110);
-                let __v_243: G = G::from_u64(60);
-                let __v_244: G = G::from_u64(58);
-                let __v_245: G = G::from_u64(245);
-                let __v_246: G = G::from_u64(79);
-                let __v_247: G = G::from_u64(165);
-                let __v_248: G = G::from_u64(127);
-                let __v_249: G = G::from_u64(82);
-                let __v_250: G = G::from_u64(14);
-                let __v_251: G = G::from_u64(81);
-                let __v_252: G = G::from_u64(140);
-                let __v_253: G = G::from_u64(104);
-                let __v_254: G = G::from_u64(5);
-                let __v_255: G = G::from_u64(155);
-                let __v_256: G = G::from_u64(171);
-                let __v_257: G = G::from_u64(217);
-                let __v_258: G = G::from_u64(131);
-                let __v_259: G = G::from_u64(31);
-                let __v_260: G = G::from_u64(25);
-                let __v_261: G = G::from_u64(205);
-                let __v_262: G = G::from_u64(224);
-                let __v_263: G = G::from_u64(91);
-                let __v_264: G = G::from_u64(0);
-                let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-                let __v_265: G = __loaded[0];
-                let __v_266: G = __loaded[1];
-                let __v_267: G = __loaded[2];
-                let __v_268: G = __loaded[3];
-                let __v_269: G = __loaded[4];
-                let __v_270: G = __loaded[5];
-                let __v_271: G = __loaded[6];
-                let __v_272: G = __loaded[7];
-                let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
-                let __v_273: G = __r_arr[0];
-                let __v_274: G = __r_arr[1];
-                let __v_275: G = __r_arr[2];
-                let __v_276: G = __r_arr[3];
-                let __v_277: G = __r_arr[4];
-                let __v_278: G = __r_arr[5];
-                let __v_279: G = __r_arr[6];
-                let __v_280: G = __r_arr[7];
-                let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_283: G = G::from_u64(0);
-                let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
-                let __v_285: G = __r_arr[0];
-                let __ret: [G; OUT_103] = [__v_285];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_232: G = G::from_u64(1);
-                let __v_233: G = (__v_2 + __v_232);
-                let __v_234: G = { let __values: [G; 32] = [__v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
-                let __v_235: G = __r_arr[0];
-                let __ret: [G; OUT_103] = [__v_235];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_104: usize = 1;
-const IN_104: usize = 1;
-const OUT_104: usize = 32;
-fn aiur_fn_104(
-  inp: [G; IN_104],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_104], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(103);
-    let __v_2: G = G::from_u64(230);
-    let __v_3: G = G::from_u64(9);
-    let __v_4: G = G::from_u64(106);
-    let __v_5: G = G::from_u64(133);
-    let __v_6: G = G::from_u64(174);
-    let __v_7: G = G::from_u64(103);
-    let __v_8: G = G::from_u64(187);
-    let __v_9: G = G::from_u64(114);
-    let __v_10: G = G::from_u64(243);
-    let __v_11: G = G::from_u64(110);
-    let __v_12: G = G::from_u64(60);
-    let __v_13: G = G::from_u64(58);
-    let __v_14: G = G::from_u64(245);
-    let __v_15: G = G::from_u64(79);
-    let __v_16: G = G::from_u64(165);
-    let __v_17: G = G::from_u64(127);
-    let __v_18: G = G::from_u64(82);
-    let __v_19: G = G::from_u64(14);
-    let __v_20: G = G::from_u64(81);
-    let __v_21: G = G::from_u64(140);
-    let __v_22: G = G::from_u64(104);
-    let __v_23: G = G::from_u64(5);
-    let __v_24: G = G::from_u64(155);
-    let __v_25: G = G::from_u64(171);
-    let __v_26: G = G::from_u64(217);
-    let __v_27: G = G::from_u64(131);
-    let __v_28: G = G::from_u64(31);
-    let __v_29: G = G::from_u64(25);
-    let __v_30: G = G::from_u64(205);
-    let __v_31: G = G::from_u64(224);
-    let __v_32: G = G::from_u64(91);
-    let __v_33: G = G::from_u64(1);
-    let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = G::from_u64(0);
-    let __v_38: G = G::from_u64(0);
-    let __v_39: G = G::from_u64(0);
-    let __v_40: G = G::from_u64(0);
-    let __v_41: G = G::from_u64(0);
-    let __v_42: G = G::from_u64(0);
-    let __v_43: G = G::from_u64(0);
-    let __v_44: G = G::from_u64(0);
-    let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = G::from_u64(1);
-    let __v_48: G = G::from_u64(1);
-    let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
-    let __v_50: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __v_52: G = __r_arr[1];
-    let __v_53: G = __r_arr[2];
-    let __v_54: G = __r_arr[3];
-    let __v_55: G = __r_arr[4];
-    let __v_56: G = __r_arr[5];
-    let __v_57: G = __r_arr[6];
-    let __v_58: G = __r_arr[7];
-    let __v_59: G = __r_arr[8];
-    let __v_60: G = __r_arr[9];
-    let __v_61: G = __r_arr[10];
-    let __v_62: G = __r_arr[11];
-    let __v_63: G = __r_arr[12];
-    let __v_64: G = __r_arr[13];
-    let __v_65: G = __r_arr[14];
-    let __v_66: G = __r_arr[15];
-    let __v_67: G = __r_arr[16];
-    let __v_68: G = __r_arr[17];
-    let __v_69: G = __r_arr[18];
-    let __v_70: G = __r_arr[19];
-    let __v_71: G = __r_arr[20];
-    let __v_72: G = __r_arr[21];
-    let __v_73: G = __r_arr[22];
-    let __v_74: G = __r_arr[23];
-    let __v_75: G = __r_arr[24];
-    let __v_76: G = __r_arr[25];
-    let __v_77: G = __r_arr[26];
-    let __v_78: G = __r_arr[27];
-    let __v_79: G = __r_arr[28];
-    let __v_80: G = __r_arr[29];
-    let __v_81: G = __r_arr[30];
-    let __v_82: G = __r_arr[31];
-    let __ret: [G; OUT_104] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82];
-    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_105: usize = 3;
-const IN_105: usize = 3;
-const OUT_105: usize = 1;
-fn aiur_fn_105(
-  inp: [G; IN_105],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_105], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(103);
-    let __v_5: G = G::from_u64(230);
-    let __v_6: G = G::from_u64(9);
-    let __v_7: G = G::from_u64(106);
-    let __v_8: G = G::from_u64(133);
-    let __v_9: G = G::from_u64(174);
-    let __v_10: G = G::from_u64(103);
-    let __v_11: G = G::from_u64(187);
-    let __v_12: G = G::from_u64(114);
-    let __v_13: G = G::from_u64(243);
-    let __v_14: G = G::from_u64(110);
-    let __v_15: G = G::from_u64(60);
-    let __v_16: G = G::from_u64(58);
-    let __v_17: G = G::from_u64(245);
-    let __v_18: G = G::from_u64(79);
-    let __v_19: G = G::from_u64(165);
-    let __v_20: G = G::from_u64(127);
-    let __v_21: G = G::from_u64(82);
-    let __v_22: G = G::from_u64(14);
-    let __v_23: G = G::from_u64(81);
-    let __v_24: G = G::from_u64(140);
-    let __v_25: G = G::from_u64(104);
-    let __v_26: G = G::from_u64(5);
-    let __v_27: G = G::from_u64(155);
-    let __v_28: G = G::from_u64(171);
-    let __v_29: G = G::from_u64(217);
-    let __v_30: G = G::from_u64(131);
-    let __v_31: G = G::from_u64(31);
-    let __v_32: G = G::from_u64(25);
-    let __v_33: G = G::from_u64(205);
-    let __v_34: G = G::from_u64(224);
-    let __v_35: G = G::from_u64(91);
-    let __v_36: G = G::from_u64(1);
-    let __v_37: G = G::from_u64(1);
-    let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_39: G = G::from_u64(0);
-    let __v_40: G = G::from_u64(0);
-    let __v_41: G = G::from_u64(0);
-    let __v_42: G = G::from_u64(0);
-    let __v_43: G = G::from_u64(0);
-    let __v_44: G = G::from_u64(0);
-    let __v_45: G = G::from_u64(0);
-    let __v_46: G = G::from_u64(0);
-    let __v_47: G = G::from_u64(0);
-    let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_50: G = G::from_u64(1);
-    let __v_51: G = G::from_u64(1);
-    let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
-    let __v_53: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
-    let __v_54: G = __r_arr[0];
-    let __v_55: G = __r_arr[1];
-    let __v_56: G = __r_arr[2];
-    let __v_57: G = __r_arr[3];
-    let __v_58: G = __r_arr[4];
-    let __v_59: G = __r_arr[5];
-    let __v_60: G = __r_arr[6];
-    let __v_61: G = __r_arr[7];
-    let __v_62: G = __r_arr[8];
-    let __v_63: G = __r_arr[9];
-    let __v_64: G = __r_arr[10];
-    let __v_65: G = __r_arr[11];
-    let __v_66: G = __r_arr[12];
-    let __v_67: G = __r_arr[13];
-    let __v_68: G = __r_arr[14];
-    let __v_69: G = __r_arr[15];
-    let __v_70: G = __r_arr[16];
-    let __v_71: G = __r_arr[17];
-    let __v_72: G = __r_arr[18];
-    let __v_73: G = __r_arr[19];
-    let __v_74: G = __r_arr[20];
-    let __v_75: G = __r_arr[21];
-    let __v_76: G = __r_arr[22];
-    let __v_77: G = __r_arr[23];
-    let __v_78: G = __r_arr[24];
-    let __v_79: G = __r_arr[25];
-    let __v_80: G = __r_arr[26];
-    let __v_81: G = __r_arr[27];
-    let __v_82: G = __r_arr[28];
-    let __v_83: G = __r_arr[29];
-    let __v_84: G = __r_arr[30];
-    let __v_85: G = __r_arr[31];
-    let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_105] = [__v_86];
-    if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_106: usize = 4;
-const IN_106: usize = 4;
-const OUT_106: usize = 1;
-fn aiur_fn_106(
-  inp: [G; IN_106],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_106], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_106] = [__v_3];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_106] = [__v_6];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_107: usize = 1;
-const IN_107: usize = 1;
-const OUT_107: usize = 1;
-fn aiur_fn_107(
-  inp: [G; IN_107],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_107] = [__v_4];
-        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = (__v_4 * __v_5);
-        let __v_7: G = (__v_2 + __v_6);
-        let __ret: [G; OUT_107] = [__v_7];
-        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_108: usize = 6;
-const IN_108: usize = 6;
-const OUT_108: usize = 2;
-fn aiur_fn_108(
-  inp: [G; IN_108],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_108] = [__v_0, __v_9];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        match __v_9.as_canonical_u64() {
-          0u64 => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
-  0u64 => {
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    break '__mc_0 [__v_12];
-  },
-  _ => {
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_7, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    break '__mc_0 [__v_12];
-  },
-}
- };
-            let __v_12: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_13.as_canonical_u64() {
-  0u64 => {
-    break '__mc_1 [__v_12];
-  },
-  _ => {
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    break '__mc_1 [__v_15];
-  },
-}
- };
-            let __v_14: G = __mc_out___mc_1[0];
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = (__v_5 - __v_15);
-            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_14, __v_1, __v_2, __v_8, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __v_18: G = __r_arr[1];
-            let __ret: [G; OUT_108] = [__v_17, __v_18];
-            if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_109: usize = 5;
-const IN_109: usize = 5;
-const OUT_109: usize = 2;
-fn aiur_fn_109(
-  inp: [G; IN_109],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_109], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = (__v_4 - __v_6);
-    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5, __v_0, __v_1, __v_3, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __ret: [G; OUT_109] = [__v_8, __v_9];
-    if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_110: usize = 6;
-const IN_110: usize = 6;
-const OUT_110: usize = 1;
-fn aiur_fn_110(
-  inp: [G; IN_110],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_110], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = G::from_u64(1);
-    let __v_8: G = (__v_5 - __v_7);
-    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_6, __v_1, __v_2, __v_4, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = (__v_11 - __v_9);
-    let __v_13: G = G::from_bool((__v_12 == G::ZERO));
-    let __ret: [G; OUT_110] = [__v_13];
-    if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_111: usize = 2;
-const IN_111: usize = 2;
-const OUT_111: usize = 1;
-fn aiur_fn_111(
-  inp: [G; IN_111],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_111], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_111] = [__v_1];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_111] = [__v_7];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_112: usize = 2;
-const IN_112: usize = 2;
-const OUT_112: usize = 1;
-fn aiur_fn_112(
-  inp: [G; IN_112],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_112], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_112] = [__v_5];
-        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = (__v_0 * __v_0);
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        match __v_3.as_canonical_u64() {
-          0u64 => {
-            let __ret: [G; OUT_112] = [__v_6];
-            if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_7: G = (__v_0 * __v_6);
-            let __ret: [G; OUT_112] = [__v_7];
-            if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_113: usize = 8;
-const IN_113: usize = 8;
-const OUT_113: usize = 2;
-fn aiur_fn_113(
-  inp: [G; IN_113],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_113], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = (__v_1 + __v_8);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = (__v_15 + __v_15);
-    let __v_17: G = (__v_4 + __v_6);
-    let __v_18: G = (__v_5 + __v_7);
-    let __v_19: G = G::from_u64(2);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = (__v_19 * __v_19);
-    let __v_22: G = G::from_u64(7);
-    let __v_23: G = (__v_20 * __v_20);
-    let __v_24: G = (__v_22 * __v_23);
-    let __v_25: G = (__v_21 - __v_24);
-    let __v_26: G = g_inverse_value(__v_25);
-    let __v_27: G = (__v_25 * __v_26);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = (__v_27 - __v_28);
-    let __v_30: G = (__v_25 * __v_29);
-    let __v_31: G = G::from_u64(0);
-    if (__v_30 != __v_31) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
-    }
-    let __v_32: G = (__v_26 * __v_29);
-    let __v_33: G = G::from_u64(0);
-    if (__v_32 != __v_33) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
-    }
-    let __v_34: G = (__v_19 * __v_26);
-    let __v_35: G = G::from_u64(0);
-    let __v_36: G = (__v_35 - __v_20);
-    let __v_37: G = (__v_36 * __v_26);
-    let __v_38: G = (__v_17 * __v_34);
-    let __v_39: G = G::from_u64(7);
-    let __v_40: G = (__v_18 * __v_37);
-    let __v_41: G = (__v_39 * __v_40);
-    let __v_42: G = (__v_38 + __v_41);
-    let __v_43: G = (__v_17 * __v_37);
-    let __v_44: G = (__v_18 * __v_34);
-    let __v_45: G = (__v_43 + __v_44);
-    let __v_46: G = (__v_4 - __v_6);
-    let __v_47: G = (__v_5 - __v_7);
-    let __v_48: G = G::from_u64(0);
-    let __v_49: G = (__v_16 * __v_16);
-    let __v_50: G = G::from_u64(7);
-    let __v_51: G = (__v_48 * __v_48);
-    let __v_52: G = (__v_50 * __v_51);
-    let __v_53: G = (__v_49 - __v_52);
-    let __v_54: G = g_inverse_value(__v_53);
-    let __v_55: G = (__v_53 * __v_54);
-    let __v_56: G = G::from_u64(1);
-    let __v_57: G = (__v_55 - __v_56);
-    let __v_58: G = (__v_53 * __v_57);
-    let __v_59: G = G::from_u64(0);
-    if (__v_58 != __v_59) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
-    }
-    let __v_60: G = (__v_54 * __v_57);
-    let __v_61: G = G::from_u64(0);
-    if (__v_60 != __v_61) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
-    }
-    let __v_62: G = (__v_16 * __v_54);
-    let __v_63: G = G::from_u64(0);
-    let __v_64: G = (__v_63 - __v_48);
-    let __v_65: G = (__v_64 * __v_54);
-    let __v_66: G = (__v_46 * __v_62);
-    let __v_67: G = G::from_u64(7);
-    let __v_68: G = (__v_47 * __v_65);
-    let __v_69: G = (__v_67 * __v_68);
-    let __v_70: G = (__v_66 + __v_69);
-    let __v_71: G = (__v_46 * __v_65);
-    let __v_72: G = (__v_47 * __v_62);
-    let __v_73: G = (__v_71 + __v_72);
-    let __v_74: G = (__v_2 * __v_70);
-    let __v_75: G = G::from_u64(7);
-    let __v_76: G = (__v_3 * __v_73);
-    let __v_77: G = (__v_75 * __v_76);
-    let __v_78: G = (__v_74 + __v_77);
-    let __v_79: G = (__v_2 * __v_73);
-    let __v_80: G = (__v_3 * __v_70);
-    let __v_81: G = (__v_79 + __v_80);
-    let __v_82: G = (__v_42 + __v_78);
-    let __v_83: G = (__v_45 + __v_81);
-    let __ret: [G; OUT_113] = [__v_82, __v_83];
-    if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_114: usize = 2;
-const IN_114: usize = 2;
-const OUT_114: usize = 1;
-fn aiur_fn_114(
-  inp: [G; IN_114],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_114], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(7);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = (__v_2 * __v_8);
-    let __ret: [G; OUT_114] = [__v_9];
-    if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_115: usize = 8;
-const IN_115: usize = 8;
-const OUT_115: usize = 4;
-fn aiur_fn_115(
-  inp: [G; IN_115],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_115], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    let __v_11: G = __loaded[3];
-    let __v_12: G = __loaded[4];
-    let __v_13: G = __loaded[5];
-    let __v_14: G = __loaded[6];
-    let __v_15: G = __loaded[7];
-    let __v_16: G = __loaded[8];
-    let __v_17: G = __loaded[9];
-    match __v_8.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_115] = [__v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_18: G = __loaded[0];
-        let __v_19: G = __loaded[1];
-        let __v_20: G = __loaded[2];
-        let __v_21: G = __loaded[3];
-        match __v_18.as_canonical_u64() {
-          0u64 => {
-            let __v_22: G = G::from_u64(256);
-            let __v_23: G = (__v_22 * __v_10);
-            let __v_24: G = G::from_u64(65536);
-            let __v_25: G = (__v_24 * __v_11);
-            let __v_26: G = G::from_u64(16777216);
-            let __v_27: G = (__v_26 * __v_12);
-            let __v_28: G = G::from_u64(4294967296);
-            let __v_29: G = (__v_28 * __v_13);
-            let __v_30: G = G::from_u64(1099511627776);
-            let __v_31: G = (__v_30 * __v_14);
-            let __v_32: G = G::from_u64(281474976710656);
-            let __v_33: G = (__v_32 * __v_15);
-            let __v_34: G = G::from_u64(72057594037927936);
-            let __v_35: G = (__v_34 * __v_16);
-            let __v_36: G = (__v_33 + __v_35);
-            let __v_37: G = (__v_31 + __v_36);
-            let __v_38: G = (__v_29 + __v_37);
-            let __v_39: G = (__v_27 + __v_38);
-            let __v_40: G = (__v_25 + __v_39);
-            let __v_41: G = (__v_23 + __v_40);
-            let __v_42: G = (__v_9 + __v_41);
-            let __v_43: G = G::from_u64(0);
-            let __v_44: G = (__v_19 - __v_42);
-            let __v_45: G = (__v_20 - __v_43);
-            let __v_46: G = (__v_6 * __v_44);
-            let __v_47: G = G::from_u64(7);
-            let __v_48: G = (__v_7 * __v_45);
-            let __v_49: G = (__v_47 * __v_48);
-            let __v_50: G = (__v_46 + __v_49);
-            let __v_51: G = (__v_6 * __v_45);
-            let __v_52: G = (__v_7 * __v_44);
-            let __v_53: G = (__v_51 + __v_52);
-            let __v_54: G = (__v_4 + __v_50);
-            let __v_55: G = (__v_5 + __v_53);
-            let __v_56: G = (__v_6 * __v_2);
-            let __v_57: G = G::from_u64(7);
-            let __v_58: G = (__v_7 * __v_3);
-            let __v_59: G = (__v_57 * __v_58);
-            let __v_60: G = (__v_56 + __v_59);
-            let __v_61: G = (__v_6 * __v_3);
-            let __v_62: G = (__v_7 * __v_2);
-            let __v_63: G = (__v_61 + __v_62);
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
-            let __v_64: G = __r_arr[0];
-            let __v_65: G = __r_arr[1];
-            let __v_66: G = __r_arr[2];
-            let __v_67: G = __r_arr[3];
-            let __ret: [G; OUT_115] = [__v_64, __v_65, __v_66, __v_67];
-            if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_116: usize = 2;
-const IN_116: usize = 2;
-const OUT_116: usize = 1;
-fn aiur_fn_116(
-  inp: [G; IN_116],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_116], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_116] = [__v_1];
-        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
-        let __v_6: G = G::from_u8(__gb[0]);
-        let __v_7: G = G::from_u8(__gb[1]);
-        let __v_8: G = G::from_u8(__gb[2]);
-        let __v_9: G = G::from_u8(__gb[3]);
-        let __v_10: G = G::from_u8(__gb[4]);
-        let __v_11: G = G::from_u8(__gb[5]);
-        let __v_12: G = G::from_u8(__gb[6]);
-        let __v_13: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_14: G = G::from_u64(1020);
-        let __v_15: G = (__v_13 - __v_14);
-        let __v_16: G = (__v_12 + __v_15);
-        let __v_17: G = (__v_11 + __v_16);
-        let __v_18: G = (__v_10 + __v_17);
-        let __v_19: G = G::from_bool((__v_18 == G::ZERO));
-        let __v_20: G = (__v_8 + __v_9);
-        let __v_21: G = (__v_7 + __v_20);
-        let __v_22: G = (__v_6 + __v_21);
-        let __v_23: G = G::from_bool((__v_22 == G::ZERO));
-        let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes();
-        let __v_24: G = G::from_u8(__gb[0]);
-        let __v_25: G = G::from_u8(__gb[1]);
-        let __v_26: G = G::from_u8(__gb[2]);
-        let __v_27: G = G::from_u8(__gb[3]);
-        let __v_28: G = G::from_u8(__gb[4]);
-        let __v_29: G = G::from_u8(__gb[5]);
-        let __v_30: G = G::from_u8(__gb[6]);
-        let __v_31: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_30; let __vj = __v_31; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_32: G = G::from_u64(1020);
-        let __v_33: G = (__v_31 - __v_32);
-        let __v_34: G = (__v_30 + __v_33);
-        let __v_35: G = (__v_29 + __v_34);
-        let __v_36: G = (__v_28 + __v_35);
-        let __v_37: G = G::from_bool((__v_36 == G::ZERO));
-        let __v_38: G = (__v_26 + __v_27);
-        let __v_39: G = (__v_25 + __v_38);
-        let __v_40: G = (__v_24 + __v_39);
-        let __v_41: G = G::from_bool((__v_40 == G::ZERO));
-        let __v_42: G = G::from_u64(256);
-        let __v_43: G = (__v_42 * __v_7);
-        let __v_44: G = G::from_u64(65536);
-        let __v_45: G = (__v_44 * __v_8);
-        let __v_46: G = G::from_u64(16777216);
-        let __v_47: G = (__v_46 * __v_9);
-        let __v_48: G = G::from_u64(4294967296);
-        let __v_49: G = (__v_48 * __v_10);
-        let __v_50: G = G::from_u64(1099511627776);
-        let __v_51: G = (__v_50 * __v_11);
-        let __v_52: G = G::from_u64(281474976710656);
-        let __v_53: G = (__v_52 * __v_12);
-        let __v_54: G = G::from_u64(72057594037927936);
-        let __v_55: G = (__v_54 * __v_13);
-        let __v_56: G = (__v_53 + __v_55);
-        let __v_57: G = (__v_51 + __v_56);
-        let __v_58: G = (__v_49 + __v_57);
-        let __v_59: G = (__v_47 + __v_58);
-        let __v_60: G = (__v_45 + __v_59);
-        let __v_61: G = (__v_43 + __v_60);
-        let __v_62: G = (__v_6 + __v_61);
-        if (__v_62 != __v_3) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
-        }
-        let __v_63: G = G::from_u64(1);
-        let __v_64: G = G::from_u64(1);
-        let __v_65: G = (__v_64 - __v_23);
-        let __v_66: G = (__v_19 * __v_65);
-        let __v_67: G = (__v_63 - __v_66);
-        let __v_68: G = G::from_u64(1);
-        if (__v_67 != __v_68) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: None });
-        }
-        let __v_69: G = G::from_u64(256);
-        let __v_70: G = (__v_69 * __v_25);
-        let __v_71: G = G::from_u64(65536);
-        let __v_72: G = (__v_71 * __v_26);
-        let __v_73: G = G::from_u64(16777216);
-        let __v_74: G = (__v_73 * __v_27);
-        let __v_75: G = G::from_u64(4294967296);
-        let __v_76: G = (__v_75 * __v_28);
-        let __v_77: G = G::from_u64(1099511627776);
-        let __v_78: G = (__v_77 * __v_29);
-        let __v_79: G = G::from_u64(281474976710656);
-        let __v_80: G = (__v_79 * __v_30);
-        let __v_81: G = G::from_u64(72057594037927936);
-        let __v_82: G = (__v_81 * __v_31);
-        let __v_83: G = (__v_80 + __v_82);
-        let __v_84: G = (__v_78 + __v_83);
-        let __v_85: G = (__v_76 + __v_84);
-        let __v_86: G = (__v_74 + __v_85);
-        let __v_87: G = (__v_72 + __v_86);
-        let __v_88: G = (__v_70 + __v_87);
-        let __v_89: G = (__v_24 + __v_88);
-        if (__v_89 != __v_4) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
-        }
-        let __v_90: G = G::from_u64(1);
-        let __v_91: G = G::from_u64(1);
-        let __v_92: G = (__v_91 - __v_41);
-        let __v_93: G = (__v_37 * __v_92);
-        let __v_94: G = (__v_90 - __v_93);
-        let __v_95: G = G::from_u64(1);
-        if (__v_94 != __v_95) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-        let __v_96: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_97: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_98: G = __r_arr[0];
-        let __ret: [G; OUT_116] = [__v_98];
-        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_117: usize = 2;
-const IN_117: usize = 2;
-const OUT_117: usize = 1;
-fn aiur_fn_117(
-  inp: [G; IN_117],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_117], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_117] = [__v_1];
-        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_117] = [__v_6];
-        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_118: usize = 2;
-const IN_118: usize = 2;
-const OUT_118: usize = 1;
-fn aiur_fn_118(
-  inp: [G; IN_118],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_118], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_118] = [__v_1];
-        if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_118] = [__v_6];
-        if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_119: usize = 3;
-const IN_119: usize = 3;
-const OUT_119: usize = 1;
-fn aiur_fn_119(
-  inp: [G; IN_119],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_119], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_119] = [__v_2];
-        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_119] = [__v_3];
-        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_120: usize = 2;
-const IN_120: usize = 2;
-const OUT_120: usize = 1;
-fn aiur_fn_120(
-  inp: [G; IN_120],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_120], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_120] = [__v_0];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_120] = [__v_14];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_121: usize = 10;
-const IN_121: usize = 10;
-const OUT_121: usize = 2;
-fn aiur_fn_121(
-  inp: [G; IN_121],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_121], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    match __v_9.as_canonical_u64() {
-      0u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_121] = [__v_0, __v_12];
-        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __v_16: G = __r_arr[2];
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(0);
-        if (__v_17 != __v_18) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
-        }
-        let __ret: [G; OUT_121] = [__v_15, __v_16];
-        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_122: usize = 4;
-const IN_122: usize = 4;
-const OUT_122: usize = 2;
-fn aiur_fn_122(
-  inp: [G; IN_122],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_122] = [__v_9, __v_0];
-        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        let __v_10: G = __loaded[3];
-        let __v_11: G = __loaded[4];
-        let __v_12: G = __loaded[5];
-        let __v_13: G = __loaded[6];
-        let __v_14: G = __loaded[7];
-        let __v_15: G = __loaded[8];
-        let __v_16: G = __loaded[9];
-        match __v_7.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = __r_arr[1];
-            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __v_21: G = __r_arr[1];
-            let __v_22: G = __r_arr[2];
-            let __v_23: G = __r_arr[3];
-            let __v_24: G = __r_arr[4];
-            let __v_25: G = __r_arr[5];
-            let __v_26: G = __r_arr[6];
-            let __v_27: G = __r_arr[7];
-            let __v_28: G = __r_arr[8];
-            let __v_29: G = __r_arr[9];
-            let __v_30: G = __r_arr[10];
-            let __v_31: G = __r_arr[11];
-            let __v_32: G = __r_arr[12];
-            let __v_33: G = __r_arr[13];
-            let __v_34: G = __r_arr[14];
-            let __v_35: G = __r_arr[15];
-            let __v_36: G = __r_arr[16];
-            let __v_37: G = __r_arr[17];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-            let __v_38: G = __r_arr[0];
-            let __v_39: G = __r_arr[1];
-            let __v_40: G = G::from_u64(0);
-            let __v_41: G = G::from_u64(256);
-            let __v_42: G = (__v_41 * __v_21);
-            let __v_43: G = G::from_u64(65536);
-            let __v_44: G = (__v_43 * __v_22);
-            let __v_45: G = G::from_u64(16777216);
-            let __v_46: G = (__v_45 * __v_23);
-            let __v_47: G = G::from_u64(4294967296);
-            let __v_48: G = (__v_47 * __v_24);
-            let __v_49: G = G::from_u64(1099511627776);
-            let __v_50: G = (__v_49 * __v_25);
-            let __v_51: G = G::from_u64(281474976710656);
-            let __v_52: G = (__v_51 * __v_26);
-            let __v_53: G = G::from_u64(72057594037927936);
-            let __v_54: G = (__v_53 * __v_27);
-            let __v_55: G = (__v_52 + __v_54);
-            let __v_56: G = (__v_50 + __v_55);
-            let __v_57: G = (__v_48 + __v_56);
-            let __v_58: G = (__v_46 + __v_57);
-            let __v_59: G = (__v_44 + __v_58);
-            let __v_60: G = (__v_42 + __v_59);
-            let __v_61: G = (__v_20 + __v_60);
-            let __v_62: G = G::from_u64(256);
-            let __v_63: G = (__v_62 * __v_29);
-            let __v_64: G = G::from_u64(65536);
-            let __v_65: G = (__v_64 * __v_30);
-            let __v_66: G = G::from_u64(16777216);
-            let __v_67: G = (__v_66 * __v_31);
-            let __v_68: G = G::from_u64(4294967296);
-            let __v_69: G = (__v_68 * __v_32);
-            let __v_70: G = G::from_u64(1099511627776);
-            let __v_71: G = (__v_70 * __v_33);
-            let __v_72: G = G::from_u64(281474976710656);
-            let __v_73: G = (__v_72 * __v_34);
-            let __v_74: G = G::from_u64(72057594037927936);
-            let __v_75: G = (__v_74 * __v_35);
-            let __v_76: G = (__v_73 + __v_75);
-            let __v_77: G = (__v_71 + __v_76);
-            let __v_78: G = (__v_69 + __v_77);
-            let __v_79: G = (__v_67 + __v_78);
-            let __v_80: G = (__v_65 + __v_79);
-            let __v_81: G = (__v_63 + __v_80);
-            let __v_82: G = (__v_28 + __v_81);
-            let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_122] = [__v_83, __v_39];
-            if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_123: usize = 5;
-const IN_123: usize = 5;
-const OUT_123: usize = 1;
-fn aiur_fn_123(
-  inp: [G; IN_123],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_123], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_123] = [__v_5];
-        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = (__v_1 - __v_4);
-        let __v_7: G = (__v_5 + __v_6);
-        let __v_8: G = G::from_bool((__v_7 == G::ZERO));
-        match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_u64(1);
-            let __ret: [G; OUT_123] = [__v_9];
-            if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = (__v_2 - __v_9);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = (__v_3 + __v_11);
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_123] = [__v_13];
-            if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_124: usize = 4;
-const IN_124: usize = 4;
-const OUT_124: usize = 1;
-fn aiur_fn_124(
-  inp: [G; IN_124],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_124], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_124] = [__v_6];
-        if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_3 - __v_6);
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_124] = [__v_8];
-            if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_6: G = G::from_u64(0);
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(0);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = (__v_3 - __v_11);
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_124] = [__v_14];
-            if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_125: usize = 8;
-const IN_125: usize = 8;
-const OUT_125: usize = 1;
-fn aiur_fn_125(
-  inp: [G; IN_125],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_125], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    let __v_11: G = __loaded[3];
-    let __v_12: G = __loaded[4];
-    let __v_13: G = __loaded[5];
-    let __v_14: G = __loaded[6];
-    match __v_8.as_canonical_u64() {
-      1u64 => {
-        let __v_15: G = G::from_u64(1);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_125] = [__v_17];
-        if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_9.as_canonical_u64() {
-          _ => {
-            let __v_15: G = (__v_9 - __v_1);
-            let __v_16: G = G::from_bool((__v_15 == G::ZERO));
-            match __v_16.as_canonical_u64() {
-              1u64 => {
-                let __v_17: G = G::from_u64(0);
-                let __v_18: G = G::from_u64(0);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
-                let __v_19: G = __r_arr[0];
-                let __v_20: G = __r_arr[1];
-                let __v_21: G = __r_arr[2];
-                let __v_22: G = __r_arr[3];
-                let __v_23: G = (__v_4 * __v_19);
-                let __v_24: G = G::from_u64(7);
-                let __v_25: G = (__v_5 * __v_20);
-                let __v_26: G = (__v_24 * __v_25);
-                let __v_27: G = (__v_23 + __v_26);
-                let __v_28: G = (__v_4 * __v_20);
-                let __v_29: G = (__v_5 * __v_19);
-                let __v_30: G = (__v_28 + __v_29);
-                let __v_31: G = (__v_12 + __v_27);
-                let __v_32: G = (__v_13 + __v_30);
-                let __v_33: G = G::from_u64(0);
-                let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_125] = [__v_34];
-                if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_17: G = G::from_u64(0);
-                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_125] = [__v_19];
-                if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_126: usize = 2;
-const IN_126: usize = 2;
-const OUT_126: usize = 1;
-fn aiur_fn_126(
-  inp: [G; IN_126],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_126], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_126] = [__v_9];
-        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_3.as_canonical_u64() {
-          _ => {
-            let __v_9: G = (__v_3 - __v_1);
-            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
-            match __v_10.as_canonical_u64() {
-              1u64 => {
-                let __v_11: G = G::from_u64(0);
-                let __v_12: G = G::from_u64(0);
-                let __v_13: G = (__v_6 - __v_11);
-                let __v_14: G = G::from_bool((__v_13 == G::ZERO));
-                let __v_15: G = (__v_7 - __v_12);
-                let __v_16: G = G::from_bool((__v_15 == G::ZERO));
-                let __v_17: G = (__v_14 * __v_16);
-                let __v_18: G = G::from_u64(1);
-                if (__v_17 != __v_18) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
-                }
-                let __v_19: G = G::from_u64(1);
-                let __ret: [G; OUT_126] = [__v_19];
-                if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_126] = [__v_11];
-                if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_127: usize = 2;
-const IN_127: usize = 2;
-const OUT_127: usize = 1;
-fn aiur_fn_127(
-  inp: [G; IN_127],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_127], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_127] = [__v_2];
-        if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_127] = [__v_2];
-        if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_128: usize = 10;
-const IN_128: usize = 10;
-const OUT_128: usize = 1;
-fn aiur_fn_128(
-  inp: [G; IN_128],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_128], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = (__v_3 - __v_1);
-    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(7);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = G::from_u64(1);
-    let __v_15: G = G::from_u64(1);
-    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __v_19: G = (__v_12 * __v_18);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = (__v_4 - __v_19);
-    let __v_22: G = (__v_5 - __v_20);
-    let __v_23: G = (__v_21 * __v_21);
-    let __v_24: G = G::from_u64(7);
-    let __v_25: G = (__v_22 * __v_22);
-    let __v_26: G = (__v_24 * __v_25);
-    let __v_27: G = (__v_23 - __v_26);
-    let __v_28: G = g_inverse_value(__v_27);
-    let __v_29: G = (__v_27 * __v_28);
-    let __v_30: G = G::from_u64(1);
-    let __v_31: G = (__v_29 - __v_30);
-    let __v_32: G = (__v_27 * __v_31);
-    let __v_33: G = G::from_u64(0);
-    if (__v_32 != __v_33) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
-    }
-    let __v_34: G = (__v_28 * __v_31);
-    let __v_35: G = G::from_u64(0);
-    if (__v_34 != __v_35) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: None });
-    }
-    let __v_36: G = (__v_21 * __v_28);
-    let __v_37: G = G::from_u64(0);
-    let __v_38: G = (__v_37 - __v_22);
-    let __v_39: G = (__v_38 * __v_28);
-    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-    let __v_40: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-    let __v_41: G = __r_arr[0];
-    let __v_42: G = (__v_40 - __v_41);
-    let __v_43: G = G::from_bool((__v_42 == G::ZERO));
-    let __v_44: G = G::from_u64(1);
-    if (__v_43 != __v_44) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
-    }
-    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
-    let __v_45: G = __r_arr[0];
-    let __ret: [G; OUT_128] = [__v_45];
-    if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_129: usize = 11;
-const IN_129: usize = 11;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_129], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = G::from_u64(0);
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __v_13: G = G::from_u64(1);
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = (__v_5 * __v_15);
-    let __v_18: G = G::from_u64(7);
-    let __v_19: G = (__v_6 * __v_16);
-    let __v_20: G = (__v_18 * __v_19);
-    let __v_21: G = (__v_17 + __v_20);
-    let __v_22: G = (__v_5 * __v_16);
-    let __v_23: G = (__v_6 * __v_15);
-    let __v_24: G = (__v_22 + __v_23);
-    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
-    let __v_26: G = __r_arr[0];
-    let __ret: [G; OUT_129] = [__v_26];
-    if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_130: usize = 13;
-const IN_130: usize = 13;
-const OUT_130: usize = 1;
-fn aiur_fn_130(
-  inp: [G; IN_130],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_130], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    match __v_5.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_130] = [__v_0];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = (__v_13 + __v_3);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(1);
-        let __v_19: G = (__v_4 + __v_18);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = (__v_5 - __v_20);
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __ret: [G; OUT_130] = [__v_22];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_131: usize = 13;
-const IN_131: usize = 13;
-const OUT_131: usize = 1;
-fn aiur_fn_131(
-  inp: [G; IN_131],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_131], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    match __v_5.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_131] = [__v_0];
-        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = (__v_13 + __v_3);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = (__v_4 + __v_20);
-        let __v_22: G = G::from_u64(1);
-        let __v_23: G = (__v_5 - __v_22);
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_131] = [__v_24];
-        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_132: usize = 15;
-const IN_132: usize = 15;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_132], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    match __v_5.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_132] = [__v_0];
-        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __v_16: G = __r_arr[1];
-        match __v_15.as_canonical_u64() {
-          0u64 => {
-            let __v_17: G = G::from_u64(1);
-            let __v_18: G = (__v_4 + __v_17);
-            let __v_19: G = G::from_u64(1);
-            let __v_20: G = (__v_5 - __v_19);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_132] = [__v_21];
-            if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __v_18: G = (__v_17 + __v_3);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = G::from_u64(1);
-            let __v_23: G = (__v_4 + __v_22);
-            let __v_24: G = G::from_u64(1);
-            let __v_25: G = (__v_5 - __v_24);
-            let __v_26: G = G::from_u64(1);
-            let __v_27: G = (__v_6 + __v_26);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __ret: [G; OUT_132] = [__v_28];
-            if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_133: usize = 15;
-const IN_133: usize = 15;
-const OUT_133: usize = 1;
-fn aiur_fn_133(
-  inp: [G; IN_133],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_133], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_133] = [__v_0];
-        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_15: G = G::from_u64(3);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
-        match __v_16.as_canonical_u64() {
-          _ => {
-            let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_6, __v_10, __v_5, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __v_23: G = (__v_21 - __v_22);
-            let __v_24: G = G::from_bool((__v_23 == G::ZERO));
-            let __v_25: G = G::from_u64(1);
-            if (__v_24 != __v_25) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
-            }
-            let __v_26: G = (__v_9 - __v_20);
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
-            let __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __v_29: G = G::from_u64(1);
-            if (__v_28 != __v_29) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
-            }
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = G::from_u64(0);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_8, __v_9, __v_10, __v_30, __v_7, __v_31, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __ret: [G; OUT_133] = [__v_32];
-            if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_134: usize = 4;
-const IN_134: usize = 4;
-const OUT_134: usize = 1;
-fn aiur_fn_134(
-  inp: [G; IN_134],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_134], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_134] = [__v_6];
-        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = (__v_5 + __v_1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_2 - __v_7);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_3 + __v_9);
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_134] = [__v_12];
-        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_135: usize = 1;
-const IN_135: usize = 1;
-const OUT_135: usize = 1;
-fn aiur_fn_135(
-  inp: [G; IN_135],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_135], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_135] = [__v_4];
-        if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __ret: [G; OUT_135] = [__v_4];
-            if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __ret: [G; OUT_135] = [__v_2];
-            if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_136: usize = 5;
-const IN_136: usize = 5;
-const OUT_136: usize = 1;
-fn aiur_fn_136(
-  inp: [G; IN_136],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_136], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_136] = [__v_7];
-        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_3 - __v_7);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = (__v_4 + __v_9);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_136] = [__v_11];
-            if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_7: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = (__v_8 + __v_1);
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = (__v_3 - __v_10);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_4 + __v_12);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_136] = [__v_15];
-            if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_137: usize = 5;
-const IN_137: usize = 5;
-const OUT_137: usize = 4;
-fn aiur_fn_137(
-  inp: [G; IN_137],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_137], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_137] = [__v_1, __v_2, __v_3, __v_4];
-        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __ret: [G; OUT_137] = [__v_3, __v_4, __v_1, __v_2];
-        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_138: usize = 4;
-const IN_138: usize = 4;
-const OUT_138: usize = 1;
-fn aiur_fn_138(
-  inp: [G; IN_138],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_138], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
-    let __v_4: G = G::from_u8(__gb[0]);
-    let __v_5: G = G::from_u8(__gb[1]);
-    let __v_6: G = G::from_u8(__gb[2]);
-    let __v_7: G = G::from_u8(__gb[3]);
-    let __v_8: G = G::from_u8(__gb[4]);
-    let __v_9: G = G::from_u8(__gb[5]);
-    let __v_10: G = G::from_u8(__gb[6]);
-    let __v_11: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_12: G = G::from_u64(1020);
-    let __v_13: G = (__v_11 - __v_12);
-    let __v_14: G = (__v_10 + __v_13);
-    let __v_15: G = (__v_9 + __v_14);
-    let __v_16: G = (__v_8 + __v_15);
-    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
-    let __v_18: G = (__v_6 + __v_7);
-    let __v_19: G = (__v_5 + __v_18);
-    let __v_20: G = (__v_4 + __v_19);
-    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
-    let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes();
-    let __v_22: G = G::from_u8(__gb[0]);
-    let __v_23: G = G::from_u8(__gb[1]);
-    let __v_24: G = G::from_u8(__gb[2]);
-    let __v_25: G = G::from_u8(__gb[3]);
-    let __v_26: G = G::from_u8(__gb[4]);
-    let __v_27: G = G::from_u8(__gb[5]);
-    let __v_28: G = G::from_u8(__gb[6]);
-    let __v_29: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_22; let __vj = __v_23; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_30: G = G::from_u64(1020);
-    let __v_31: G = (__v_29 - __v_30);
-    let __v_32: G = (__v_28 + __v_31);
-    let __v_33: G = (__v_27 + __v_32);
-    let __v_34: G = (__v_26 + __v_33);
-    let __v_35: G = G::from_bool((__v_34 == G::ZERO));
-    let __v_36: G = (__v_24 + __v_25);
-    let __v_37: G = (__v_23 + __v_36);
-    let __v_38: G = (__v_22 + __v_37);
-    let __v_39: G = G::from_bool((__v_38 == G::ZERO));
-    let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes();
-    let __v_40: G = G::from_u8(__gb[0]);
-    let __v_41: G = G::from_u8(__gb[1]);
-    let __v_42: G = G::from_u8(__gb[2]);
-    let __v_43: G = G::from_u8(__gb[3]);
-    let __v_44: G = G::from_u8(__gb[4]);
-    let __v_45: G = G::from_u8(__gb[5]);
-    let __v_46: G = G::from_u8(__gb[6]);
-    let __v_47: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_48: G = G::from_u64(1020);
-    let __v_49: G = (__v_47 - __v_48);
-    let __v_50: G = (__v_46 + __v_49);
-    let __v_51: G = (__v_45 + __v_50);
-    let __v_52: G = (__v_44 + __v_51);
-    let __v_53: G = G::from_bool((__v_52 == G::ZERO));
-    let __v_54: G = (__v_42 + __v_43);
-    let __v_55: G = (__v_41 + __v_54);
-    let __v_56: G = (__v_40 + __v_55);
-    let __v_57: G = G::from_bool((__v_56 == G::ZERO));
-    let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
-    let __v_58: G = G::from_u8(__gb[0]);
-    let __v_59: G = G::from_u8(__gb[1]);
-    let __v_60: G = G::from_u8(__gb[2]);
-    let __v_61: G = G::from_u8(__gb[3]);
-    let __v_62: G = G::from_u8(__gb[4]);
-    let __v_63: G = G::from_u8(__gb[5]);
-    let __v_64: G = G::from_u8(__gb[6]);
-    let __v_65: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_66: G = G::from_u64(1020);
-    let __v_67: G = (__v_65 - __v_66);
-    let __v_68: G = (__v_64 + __v_67);
-    let __v_69: G = (__v_63 + __v_68);
-    let __v_70: G = (__v_62 + __v_69);
-    let __v_71: G = G::from_bool((__v_70 == G::ZERO));
-    let __v_72: G = (__v_60 + __v_61);
-    let __v_73: G = (__v_59 + __v_72);
-    let __v_74: G = (__v_58 + __v_73);
-    let __v_75: G = G::from_bool((__v_74 == G::ZERO));
-    let __v_76: G = G::from_u64(0);
-    let __v_77: G = G::from_u64(256);
-    let __v_78: G = (__v_77 * __v_5);
-    let __v_79: G = G::from_u64(65536);
-    let __v_80: G = (__v_79 * __v_6);
-    let __v_81: G = G::from_u64(16777216);
-    let __v_82: G = (__v_81 * __v_7);
-    let __v_83: G = G::from_u64(4294967296);
-    let __v_84: G = (__v_83 * __v_8);
-    let __v_85: G = G::from_u64(1099511627776);
-    let __v_86: G = (__v_85 * __v_9);
-    let __v_87: G = G::from_u64(281474976710656);
-    let __v_88: G = (__v_87 * __v_10);
-    let __v_89: G = G::from_u64(72057594037927936);
-    let __v_90: G = (__v_89 * __v_11);
-    let __v_91: G = (__v_88 + __v_90);
-    let __v_92: G = (__v_86 + __v_91);
-    let __v_93: G = (__v_84 + __v_92);
-    let __v_94: G = (__v_82 + __v_93);
-    let __v_95: G = (__v_80 + __v_94);
-    let __v_96: G = (__v_78 + __v_95);
-    let __v_97: G = (__v_4 + __v_96);
-    if (__v_97 != __v_0) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
-    }
-    let __v_98: G = G::from_u64(1);
-    let __v_99: G = G::from_u64(1);
-    let __v_100: G = (__v_99 - __v_21);
-    let __v_101: G = (__v_17 * __v_100);
-    let __v_102: G = (__v_98 - __v_101);
-    let __v_103: G = G::from_u64(1);
-    if (__v_102 != __v_103) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None });
-    }
-    let __v_104: G = G::from_u64(0);
-    let __v_105: G = G::from_u64(256);
-    let __v_106: G = (__v_105 * __v_23);
-    let __v_107: G = G::from_u64(65536);
-    let __v_108: G = (__v_107 * __v_24);
-    let __v_109: G = G::from_u64(16777216);
-    let __v_110: G = (__v_109 * __v_25);
-    let __v_111: G = G::from_u64(4294967296);
-    let __v_112: G = (__v_111 * __v_26);
-    let __v_113: G = G::from_u64(1099511627776);
-    let __v_114: G = (__v_113 * __v_27);
-    let __v_115: G = G::from_u64(281474976710656);
-    let __v_116: G = (__v_115 * __v_28);
-    let __v_117: G = G::from_u64(72057594037927936);
-    let __v_118: G = (__v_117 * __v_29);
-    let __v_119: G = (__v_116 + __v_118);
-    let __v_120: G = (__v_114 + __v_119);
-    let __v_121: G = (__v_112 + __v_120);
-    let __v_122: G = (__v_110 + __v_121);
-    let __v_123: G = (__v_108 + __v_122);
-    let __v_124: G = (__v_106 + __v_123);
-    let __v_125: G = (__v_22 + __v_124);
-    if (__v_125 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
-    }
-    let __v_126: G = G::from_u64(1);
-    let __v_127: G = G::from_u64(1);
-    let __v_128: G = (__v_127 - __v_39);
-    let __v_129: G = (__v_35 * __v_128);
-    let __v_130: G = (__v_126 - __v_129);
-    let __v_131: G = G::from_u64(1);
-    if (__v_130 != __v_131) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
-    }
-    let __v_132: G = G::from_u64(0);
-    let __v_133: G = G::from_u64(256);
-    let __v_134: G = (__v_133 * __v_41);
-    let __v_135: G = G::from_u64(65536);
-    let __v_136: G = (__v_135 * __v_42);
-    let __v_137: G = G::from_u64(16777216);
-    let __v_138: G = (__v_137 * __v_43);
-    let __v_139: G = G::from_u64(4294967296);
-    let __v_140: G = (__v_139 * __v_44);
-    let __v_141: G = G::from_u64(1099511627776);
-    let __v_142: G = (__v_141 * __v_45);
-    let __v_143: G = G::from_u64(281474976710656);
-    let __v_144: G = (__v_143 * __v_46);
-    let __v_145: G = G::from_u64(72057594037927936);
-    let __v_146: G = (__v_145 * __v_47);
-    let __v_147: G = (__v_144 + __v_146);
-    let __v_148: G = (__v_142 + __v_147);
-    let __v_149: G = (__v_140 + __v_148);
-    let __v_150: G = (__v_138 + __v_149);
-    let __v_151: G = (__v_136 + __v_150);
-    let __v_152: G = (__v_134 + __v_151);
-    let __v_153: G = (__v_40 + __v_152);
-    if (__v_153 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
-    }
-    let __v_154: G = G::from_u64(1);
-    let __v_155: G = G::from_u64(1);
-    let __v_156: G = (__v_155 - __v_57);
-    let __v_157: G = (__v_53 * __v_156);
-    let __v_158: G = (__v_154 - __v_157);
-    let __v_159: G = G::from_u64(1);
-    if (__v_158 != __v_159) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_159.as_canonical_u64(), msg: None });
-    }
-    let __v_160: G = G::from_u64(0);
-    let __v_161: G = G::from_u64(256);
-    let __v_162: G = (__v_161 * __v_59);
-    let __v_163: G = G::from_u64(65536);
-    let __v_164: G = (__v_163 * __v_60);
-    let __v_165: G = G::from_u64(16777216);
-    let __v_166: G = (__v_165 * __v_61);
-    let __v_167: G = G::from_u64(4294967296);
-    let __v_168: G = (__v_167 * __v_62);
-    let __v_169: G = G::from_u64(1099511627776);
-    let __v_170: G = (__v_169 * __v_63);
-    let __v_171: G = G::from_u64(281474976710656);
-    let __v_172: G = (__v_171 * __v_64);
-    let __v_173: G = G::from_u64(72057594037927936);
-    let __v_174: G = (__v_173 * __v_65);
-    let __v_175: G = (__v_172 + __v_174);
-    let __v_176: G = (__v_170 + __v_175);
-    let __v_177: G = (__v_168 + __v_176);
-    let __v_178: G = (__v_166 + __v_177);
-    let __v_179: G = (__v_164 + __v_178);
-    let __v_180: G = (__v_162 + __v_179);
-    let __v_181: G = (__v_58 + __v_180);
-    if (__v_181 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
-    }
-    let __v_182: G = G::from_u64(1);
-    let __v_183: G = G::from_u64(1);
-    let __v_184: G = (__v_183 - __v_75);
-    let __v_185: G = (__v_71 * __v_184);
-    let __v_186: G = (__v_182 - __v_185);
-    let __v_187: G = G::from_u64(1);
-    if (__v_186 != __v_187) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: None });
-    }
-    let __v_188: G = G::from_u64(1);
-    let __v_189: G = G::from_u64(1);
-    let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_138] = [__v_194];
-    if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_139: usize = 6;
-const IN_139: usize = 6;
-const OUT_139: usize = 3;
-fn aiur_fn_139(
-  inp: [G; IN_139],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_139], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    let __v_9: G = __loaded[3];
-    let __v_10: G = __loaded[4];
-    let __v_11: G = __loaded[5];
-    let __v_12: G = __loaded[6];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_139] = [__v_0, __v_1, __v_5];
-        if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_7.as_canonical_u64() {
-          _ => {
-            let __v_13: G = (__v_7 - __v_2);
-            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
-            match __v_14.as_canonical_u64() {
-              1u64 => {
-                let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                let __v_17: G = __r_arr[1];
-                let __v_18: G = (__v_16 * __v_10);
-                let __v_19: G = G::from_u64(7);
-                let __v_20: G = (__v_17 * __v_11);
-                let __v_21: G = (__v_19 * __v_20);
-                let __v_22: G = (__v_18 + __v_21);
-                let __v_23: G = (__v_16 * __v_11);
-                let __v_24: G = (__v_17 * __v_10);
-                let __v_25: G = (__v_23 + __v_24);
-                let __v_26: G = (__v_0 + __v_22);
-                let __v_27: G = (__v_1 + __v_25);
-                let __ret: [G; OUT_139] = [__v_26, __v_27, __v_12];
-                if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __ret: [G; OUT_139] = [__v_0, __v_1, __v_5];
-                if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_140: usize = 9;
-const IN_140: usize = 9;
-const OUT_140: usize = 2;
-fn aiur_fn_140(
-  inp: [G; IN_140],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_140], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_14: G = (__v_6 - __v_8);
-        let __v_15: G = G::from_bool((__v_14 == G::ZERO));
-        let __v_16: G = G::from_u64(1);
-        if (__v_15 != __v_16) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(0);
-        if (__v_17 != __v_18) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
-        }
-        let __ret: [G; OUT_140] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_14: G = __loaded[0];
-        let __v_15: G = __loaded[1];
-        let __v_16: G = __loaded[2];
-        let __v_17: G = __loaded[3];
-        match __v_14.as_canonical_u64() {
-          0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_18: G = __loaded[0];
-            let __v_19: G = __loaded[1];
-            let __v_20: G = __loaded[2];
-            match __v_18.as_canonical_u64() {
-              0u64 => {
-                match __v_10.as_canonical_u64() {
-                  _ => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_21: G = __loaded[0];
-                    let __v_22: G = __loaded[1];
-                    let __v_23: G = __loaded[2];
-                    match __v_21.as_canonical_u64() {
-                      0u64 => {
-                        let __v_24: G = G::from_u64(1);
-                        let __v_25: G = (__v_6 - __v_24);
-                        let __v_26: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                        let __v_27: G = __r_arr[0];
-                        let __v_28: G = __r_arr[1];
-                        let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_22.as_canonical_u64() {
-  0u64 => {
-    break '__mc_0 [__v_0, __v_1, __v_27, __v_28];
-  },
-  _ => {
-    break '__mc_0 [__v_27, __v_28, __v_0, __v_1];
-  },
-}
- };
-                        let __v_29: G = __mc_out___mc_0[0];
-                        let __v_30: G = __mc_out___mc_0[1];
-                        let __v_31: G = __mc_out___mc_0[2];
-                        let __v_32: G = __mc_out___mc_0[3];
-                        let __gb: [u8; 8] = __v_29.as_canonical_u64().to_le_bytes();
-                        let __v_33: G = G::from_u8(__gb[0]);
-                        let __v_34: G = G::from_u8(__gb[1]);
-                        let __v_35: G = G::from_u8(__gb[2]);
-                        let __v_36: G = G::from_u8(__gb[3]);
-                        let __v_37: G = G::from_u8(__gb[4]);
-                        let __v_38: G = G::from_u8(__gb[5]);
-                        let __v_39: G = G::from_u8(__gb[6]);
-                        let __v_40: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_41: G = G::from_u64(1020);
-                        let __v_42: G = (__v_40 - __v_41);
-                        let __v_43: G = (__v_39 + __v_42);
-                        let __v_44: G = (__v_38 + __v_43);
-                        let __v_45: G = (__v_37 + __v_44);
-                        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
-                        let __v_47: G = (__v_35 + __v_36);
-                        let __v_48: G = (__v_34 + __v_47);
-                        let __v_49: G = (__v_33 + __v_48);
-                        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
-                        let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes();
-                        let __v_51: G = G::from_u8(__gb[0]);
-                        let __v_52: G = G::from_u8(__gb[1]);
-                        let __v_53: G = G::from_u8(__gb[2]);
-                        let __v_54: G = G::from_u8(__gb[3]);
-                        let __v_55: G = G::from_u8(__gb[4]);
-                        let __v_56: G = G::from_u8(__gb[5]);
-                        let __v_57: G = G::from_u8(__gb[6]);
-                        let __v_58: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_55; let __vj = __v_56; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_57; let __vj = __v_58; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_59: G = G::from_u64(1020);
-                        let __v_60: G = (__v_58 - __v_59);
-                        let __v_61: G = (__v_57 + __v_60);
-                        let __v_62: G = (__v_56 + __v_61);
-                        let __v_63: G = (__v_55 + __v_62);
-                        let __v_64: G = G::from_bool((__v_63 == G::ZERO));
-                        let __v_65: G = (__v_53 + __v_54);
-                        let __v_66: G = (__v_52 + __v_65);
-                        let __v_67: G = (__v_51 + __v_66);
-                        let __v_68: G = G::from_bool((__v_67 == G::ZERO));
-                        let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes();
-                        let __v_69: G = G::from_u8(__gb[0]);
-                        let __v_70: G = G::from_u8(__gb[1]);
-                        let __v_71: G = G::from_u8(__gb[2]);
-                        let __v_72: G = G::from_u8(__gb[3]);
-                        let __v_73: G = G::from_u8(__gb[4]);
-                        let __v_74: G = G::from_u8(__gb[5]);
-                        let __v_75: G = G::from_u8(__gb[6]);
-                        let __v_76: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_69; let __vj = __v_70; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_75; let __vj = __v_76; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_77: G = G::from_u64(1020);
-                        let __v_78: G = (__v_76 - __v_77);
-                        let __v_79: G = (__v_75 + __v_78);
-                        let __v_80: G = (__v_74 + __v_79);
-                        let __v_81: G = (__v_73 + __v_80);
-                        let __v_82: G = G::from_bool((__v_81 == G::ZERO));
-                        let __v_83: G = (__v_71 + __v_72);
-                        let __v_84: G = (__v_70 + __v_83);
-                        let __v_85: G = (__v_69 + __v_84);
-                        let __v_86: G = G::from_bool((__v_85 == G::ZERO));
-                        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
-                        let __v_87: G = G::from_u8(__gb[0]);
-                        let __v_88: G = G::from_u8(__gb[1]);
-                        let __v_89: G = G::from_u8(__gb[2]);
-                        let __v_90: G = G::from_u8(__gb[3]);
-                        let __v_91: G = G::from_u8(__gb[4]);
-                        let __v_92: G = G::from_u8(__gb[5]);
-                        let __v_93: G = G::from_u8(__gb[6]);
-                        let __v_94: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_93; let __vj = __v_94; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_95: G = G::from_u64(1020);
-                        let __v_96: G = (__v_94 - __v_95);
-                        let __v_97: G = (__v_93 + __v_96);
-                        let __v_98: G = (__v_92 + __v_97);
-                        let __v_99: G = (__v_91 + __v_98);
-                        let __v_100: G = G::from_bool((__v_99 == G::ZERO));
-                        let __v_101: G = (__v_89 + __v_90);
-                        let __v_102: G = (__v_88 + __v_101);
-                        let __v_103: G = (__v_87 + __v_102);
-                        let __v_104: G = G::from_bool((__v_103 == G::ZERO));
-                        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
-                        let __v_105: G = __r_arr[0];
-                        let __v_106: G = __r_arr[1];
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
-                        let __v_107: G = __r_arr[0];
-                        let __v_108: G = __r_arr[1];
-                        let __v_109: G = __r_arr[2];
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                        let __v_110: G = __r_arr[0];
-                        let __v_111: G = G::from_u64(1);
-                        if (__v_110 != __v_111) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_110.as_canonical_u64(), rhs: __v_111.as_canonical_u64(), msg: None });
-                        }
-                        let __v_112: G = G::from_u64(0);
-                        let __v_113: G = G::from_u64(0);
-                        let __v_114: G = G::from_u64(256);
-                        let __v_115: G = (__v_114 * __v_34);
-                        let __v_116: G = G::from_u64(65536);
-                        let __v_117: G = (__v_116 * __v_35);
-                        let __v_118: G = G::from_u64(16777216);
-                        let __v_119: G = (__v_118 * __v_36);
-                        let __v_120: G = G::from_u64(4294967296);
-                        let __v_121: G = (__v_120 * __v_37);
-                        let __v_122: G = G::from_u64(1099511627776);
-                        let __v_123: G = (__v_122 * __v_38);
-                        let __v_124: G = G::from_u64(281474976710656);
-                        let __v_125: G = (__v_124 * __v_39);
-                        let __v_126: G = G::from_u64(72057594037927936);
-                        let __v_127: G = (__v_126 * __v_40);
-                        let __v_128: G = (__v_125 + __v_127);
-                        let __v_129: G = (__v_123 + __v_128);
-                        let __v_130: G = (__v_121 + __v_129);
-                        let __v_131: G = (__v_119 + __v_130);
-                        let __v_132: G = (__v_117 + __v_131);
-                        let __v_133: G = (__v_115 + __v_132);
-                        let __v_134: G = (__v_33 + __v_133);
-                        if (__v_134 != __v_29) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
-                        }
-                        let __v_135: G = G::from_u64(1);
-                        let __v_136: G = G::from_u64(1);
-                        let __v_137: G = (__v_136 - __v_50);
-                        let __v_138: G = (__v_46 * __v_137);
-                        let __v_139: G = (__v_135 - __v_138);
-                        let __v_140: G = G::from_u64(1);
-                        if (__v_139 != __v_140) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: None });
-                        }
-                        let __v_141: G = G::from_u64(0);
-                        let __v_142: G = G::from_u64(256);
-                        let __v_143: G = (__v_142 * __v_52);
-                        let __v_144: G = G::from_u64(65536);
-                        let __v_145: G = (__v_144 * __v_53);
-                        let __v_146: G = G::from_u64(16777216);
-                        let __v_147: G = (__v_146 * __v_54);
-                        let __v_148: G = G::from_u64(4294967296);
-                        let __v_149: G = (__v_148 * __v_55);
-                        let __v_150: G = G::from_u64(1099511627776);
-                        let __v_151: G = (__v_150 * __v_56);
-                        let __v_152: G = G::from_u64(281474976710656);
-                        let __v_153: G = (__v_152 * __v_57);
-                        let __v_154: G = G::from_u64(72057594037927936);
-                        let __v_155: G = (__v_154 * __v_58);
-                        let __v_156: G = (__v_153 + __v_155);
-                        let __v_157: G = (__v_151 + __v_156);
-                        let __v_158: G = (__v_149 + __v_157);
-                        let __v_159: G = (__v_147 + __v_158);
-                        let __v_160: G = (__v_145 + __v_159);
-                        let __v_161: G = (__v_143 + __v_160);
-                        let __v_162: G = (__v_51 + __v_161);
-                        if (__v_162 != __v_30) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
-                        }
-                        let __v_163: G = G::from_u64(1);
-                        let __v_164: G = G::from_u64(1);
-                        let __v_165: G = (__v_164 - __v_68);
-                        let __v_166: G = (__v_64 * __v_165);
-                        let __v_167: G = (__v_163 - __v_166);
-                        let __v_168: G = G::from_u64(1);
-                        if (__v_167 != __v_168) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_168.as_canonical_u64(), msg: None });
-                        }
-                        let __v_169: G = G::from_u64(0);
-                        let __v_170: G = G::from_u64(256);
-                        let __v_171: G = (__v_170 * __v_70);
-                        let __v_172: G = G::from_u64(65536);
-                        let __v_173: G = (__v_172 * __v_71);
-                        let __v_174: G = G::from_u64(16777216);
-                        let __v_175: G = (__v_174 * __v_72);
-                        let __v_176: G = G::from_u64(4294967296);
-                        let __v_177: G = (__v_176 * __v_73);
-                        let __v_178: G = G::from_u64(1099511627776);
-                        let __v_179: G = (__v_178 * __v_74);
-                        let __v_180: G = G::from_u64(281474976710656);
-                        let __v_181: G = (__v_180 * __v_75);
-                        let __v_182: G = G::from_u64(72057594037927936);
-                        let __v_183: G = (__v_182 * __v_76);
-                        let __v_184: G = (__v_181 + __v_183);
-                        let __v_185: G = (__v_179 + __v_184);
-                        let __v_186: G = (__v_177 + __v_185);
-                        let __v_187: G = (__v_175 + __v_186);
-                        let __v_188: G = (__v_173 + __v_187);
-                        let __v_189: G = (__v_171 + __v_188);
-                        let __v_190: G = (__v_69 + __v_189);
-                        if (__v_190 != __v_31) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
-                        }
-                        let __v_191: G = G::from_u64(1);
-                        let __v_192: G = G::from_u64(1);
-                        let __v_193: G = (__v_192 - __v_86);
-                        let __v_194: G = (__v_82 * __v_193);
-                        let __v_195: G = (__v_191 - __v_194);
-                        let __v_196: G = G::from_u64(1);
-                        if (__v_195 != __v_196) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None });
-                        }
-                        let __v_197: G = G::from_u64(0);
-                        let __v_198: G = G::from_u64(256);
-                        let __v_199: G = (__v_198 * __v_88);
-                        let __v_200: G = G::from_u64(65536);
-                        let __v_201: G = (__v_200 * __v_89);
-                        let __v_202: G = G::from_u64(16777216);
-                        let __v_203: G = (__v_202 * __v_90);
-                        let __v_204: G = G::from_u64(4294967296);
-                        let __v_205: G = (__v_204 * __v_91);
-                        let __v_206: G = G::from_u64(1099511627776);
-                        let __v_207: G = (__v_206 * __v_92);
-                        let __v_208: G = G::from_u64(281474976710656);
-                        let __v_209: G = (__v_208 * __v_93);
-                        let __v_210: G = G::from_u64(72057594037927936);
-                        let __v_211: G = (__v_210 * __v_94);
-                        let __v_212: G = (__v_209 + __v_211);
-                        let __v_213: G = (__v_207 + __v_212);
-                        let __v_214: G = (__v_205 + __v_213);
-                        let __v_215: G = (__v_203 + __v_214);
-                        let __v_216: G = (__v_201 + __v_215);
-                        let __v_217: G = (__v_199 + __v_216);
-                        let __v_218: G = (__v_87 + __v_217);
-                        if (__v_218 != __v_32) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
-                        }
-                        let __v_219: G = G::from_u64(1);
-                        let __v_220: G = G::from_u64(1);
-                        let __v_221: G = (__v_220 - __v_104);
-                        let __v_222: G = (__v_100 * __v_221);
-                        let __v_223: G = (__v_219 - __v_222);
-                        let __v_224: G = G::from_u64(1);
-                        if (__v_223 != __v_224) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_224.as_canonical_u64(), msg: None });
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_14, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_18, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+    let __v_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } };
+    let __v_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_23: G = __r_arr[0];
+    let __v_24: G = __r_arr[1];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __v_25: G = __r_arr[0];
+    let __v_26: G = __r_arr[1];
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+    let __v_27: G = __r_arr[0];
+    let __v_28: G = __r_arr[1];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_29: G = __r_arr[0];
+    let __v_30: G = __r_arr[1];
+    let __v_31: G = __r_arr[2];
+    let __v_32: G = __r_arr[3];
+    let __v_33: G = __r_arr[4];
+    let __v_34: G = __r_arr[5];
+    let __v_35: G = __r_arr[6];
+    let __v_36: G = __r_arr[7];
+    let __v_37: G = __r_arr[8];
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+    let __v_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
+    let __v_40: G = __r_arr[0];
+    let __v_41: G = __r_arr[1];
+    let __v_42: G = __r_arr[2];
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+    let __v_43: G = __r_arr[0];
+    let __v_44: G = __r_arr[1];
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+    let __v_45: G = __r_arr[0];
+    let __v_46: G = __r_arr[1];
+    let __ret: [G; OUT_69] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_40, __v_41, __v_43, __v_45, __v_46];
+    if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_70: usize = 4;
+const IN_70: usize = 4;
+const OUT_70: usize = 1;
+fn aiur_fn_70(
+  inp: [G; IN_70],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_70], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(256);
+    let __v_5: G = (__v_4 * __v_1);
+    let __v_6: G = G::from_u64(65536);
+    let __v_7: G = (__v_6 * __v_2);
+    let __v_8: G = G::from_u64(16777216);
+    let __v_9: G = (__v_8 * __v_3);
+    let __v_10: G = (__v_7 + __v_9);
+    let __v_11: G = (__v_5 + __v_10);
+    let __v_12: G = (__v_0 + __v_11);
+    let __ret: [G; OUT_70] = [__v_12];
+    if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_71: usize = 32;
+const IN_71: usize = 32;
+const OUT_71: usize = 8;
+fn aiur_fn_71(
+  inp: [G; IN_71],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_71], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = G::from_u64(256);
+    let __v_33: G = (__v_32 * __v_1);
+    let __v_34: G = G::from_u64(65536);
+    let __v_35: G = (__v_34 * __v_2);
+    let __v_36: G = G::from_u64(16777216);
+    let __v_37: G = (__v_36 * __v_3);
+    let __v_38: G = (__v_35 + __v_37);
+    let __v_39: G = (__v_33 + __v_38);
+    let __v_40: G = (__v_0 + __v_39);
+    let __v_41: G = G::from_u64(256);
+    let __v_42: G = (__v_41 * __v_5);
+    let __v_43: G = G::from_u64(65536);
+    let __v_44: G = (__v_43 * __v_6);
+    let __v_45: G = G::from_u64(16777216);
+    let __v_46: G = (__v_45 * __v_7);
+    let __v_47: G = (__v_44 + __v_46);
+    let __v_48: G = (__v_42 + __v_47);
+    let __v_49: G = (__v_4 + __v_48);
+    let __v_50: G = G::from_u64(256);
+    let __v_51: G = (__v_50 * __v_9);
+    let __v_52: G = G::from_u64(65536);
+    let __v_53: G = (__v_52 * __v_10);
+    let __v_54: G = G::from_u64(16777216);
+    let __v_55: G = (__v_54 * __v_11);
+    let __v_56: G = (__v_53 + __v_55);
+    let __v_57: G = (__v_51 + __v_56);
+    let __v_58: G = (__v_8 + __v_57);
+    let __v_59: G = G::from_u64(256);
+    let __v_60: G = (__v_59 * __v_13);
+    let __v_61: G = G::from_u64(65536);
+    let __v_62: G = (__v_61 * __v_14);
+    let __v_63: G = G::from_u64(16777216);
+    let __v_64: G = (__v_63 * __v_15);
+    let __v_65: G = (__v_62 + __v_64);
+    let __v_66: G = (__v_60 + __v_65);
+    let __v_67: G = (__v_12 + __v_66);
+    let __v_68: G = G::from_u64(256);
+    let __v_69: G = (__v_68 * __v_17);
+    let __v_70: G = G::from_u64(65536);
+    let __v_71: G = (__v_70 * __v_18);
+    let __v_72: G = G::from_u64(16777216);
+    let __v_73: G = (__v_72 * __v_19);
+    let __v_74: G = (__v_71 + __v_73);
+    let __v_75: G = (__v_69 + __v_74);
+    let __v_76: G = (__v_16 + __v_75);
+    let __v_77: G = G::from_u64(256);
+    let __v_78: G = (__v_77 * __v_21);
+    let __v_79: G = G::from_u64(65536);
+    let __v_80: G = (__v_79 * __v_22);
+    let __v_81: G = G::from_u64(16777216);
+    let __v_82: G = (__v_81 * __v_23);
+    let __v_83: G = (__v_80 + __v_82);
+    let __v_84: G = (__v_78 + __v_83);
+    let __v_85: G = (__v_20 + __v_84);
+    let __v_86: G = G::from_u64(256);
+    let __v_87: G = (__v_86 * __v_25);
+    let __v_88: G = G::from_u64(65536);
+    let __v_89: G = (__v_88 * __v_26);
+    let __v_90: G = G::from_u64(16777216);
+    let __v_91: G = (__v_90 * __v_27);
+    let __v_92: G = (__v_89 + __v_91);
+    let __v_93: G = (__v_87 + __v_92);
+    let __v_94: G = (__v_24 + __v_93);
+    let __v_95: G = G::from_u64(256);
+    let __v_96: G = (__v_95 * __v_29);
+    let __v_97: G = G::from_u64(65536);
+    let __v_98: G = (__v_97 * __v_30);
+    let __v_99: G = G::from_u64(16777216);
+    let __v_100: G = (__v_99 * __v_31);
+    let __v_101: G = (__v_98 + __v_100);
+    let __v_102: G = (__v_96 + __v_101);
+    let __v_103: G = (__v_28 + __v_102);
+    let __ret: [G; OUT_71] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
+    if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_72: usize = 1;
+const IN_72: usize = 1;
+const OUT_72: usize = 32;
+fn aiur_fn_72(
+  inp: [G; IN_72],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_72], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(103);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(9);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(103);
+    let __v_8: G = G::from_u64(187);
+    let __v_9: G = G::from_u64(114);
+    let __v_10: G = G::from_u64(243);
+    let __v_11: G = G::from_u64(110);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(245);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(165);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(82);
+    let __v_19: G = G::from_u64(14);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(104);
+    let __v_23: G = G::from_u64(5);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(217);
+    let __v_27: G = G::from_u64(131);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(25);
+    let __v_30: G = G::from_u64(205);
+    let __v_31: G = G::from_u64(224);
+    let __v_32: G = G::from_u64(91);
+    let __v_33: G = G::from_u64(1);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = G::from_u64(1);
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __v_52: G = __r_arr[0];
+    let __v_53: G = __r_arr[1];
+    let __v_54: G = __r_arr[2];
+    let __v_55: G = __r_arr[3];
+    let __v_56: G = __r_arr[4];
+    let __v_57: G = __r_arr[5];
+    let __v_58: G = __r_arr[6];
+    let __v_59: G = __r_arr[7];
+    let __v_60: G = __r_arr[8];
+    let __v_61: G = __r_arr[9];
+    let __v_62: G = __r_arr[10];
+    let __v_63: G = __r_arr[11];
+    let __v_64: G = __r_arr[12];
+    let __v_65: G = __r_arr[13];
+    let __v_66: G = __r_arr[14];
+    let __v_67: G = __r_arr[15];
+    let __v_68: G = __r_arr[16];
+    let __v_69: G = __r_arr[17];
+    let __v_70: G = __r_arr[18];
+    let __v_71: G = __r_arr[19];
+    let __v_72: G = __r_arr[20];
+    let __v_73: G = __r_arr[21];
+    let __v_74: G = __r_arr[22];
+    let __v_75: G = __r_arr[23];
+    let __v_76: G = __r_arr[24];
+    let __v_77: G = __r_arr[25];
+    let __v_78: G = __r_arr[26];
+    let __v_79: G = __r_arr[27];
+    let __v_80: G = __r_arr[28];
+    let __v_81: G = __r_arr[29];
+    let __v_82: G = __r_arr[30];
+    let __v_83: G = __r_arr[31];
+    let __ret: [G; OUT_72] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83];
+    if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_73: usize = 34;
+const IN_73: usize = 34;
+const OUT_73: usize = 34;
+fn aiur_fn_73(
+  inp: [G; IN_73],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_73], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __v_66: G = __loaded[32];
+    let __v_67: G = __loaded[33];
+    match __v_34.as_canonical_u64() {
+      1u64 => {
+        let __v_68: G = G::from_u64(1);
+        let __ret: [G; OUT_73] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
+        if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_68: G = G::from_u64(0);
+        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+        let __v_69: G = __r_arr[0];
+        let __v_70: G = __r_arr[1];
+        let __v_71: G = __r_arr[2];
+        let __v_72: G = __r_arr[3];
+        let __v_73: G = __r_arr[4];
+        let __v_74: G = __r_arr[5];
+        let __v_75: G = __r_arr[6];
+        let __v_76: G = __r_arr[7];
+        let __v_77: G = __r_arr[8];
+        let __v_78: G = __r_arr[9];
+        let __v_79: G = __r_arr[10];
+        let __v_80: G = __r_arr[11];
+        let __v_81: G = __r_arr[12];
+        let __v_82: G = __r_arr[13];
+        let __v_83: G = __r_arr[14];
+        let __v_84: G = __r_arr[15];
+        let __v_85: G = __r_arr[16];
+        let __v_86: G = __r_arr[17];
+        let __v_87: G = __r_arr[18];
+        let __v_88: G = __r_arr[19];
+        let __v_89: G = __r_arr[20];
+        let __v_90: G = __r_arr[21];
+        let __v_91: G = __r_arr[22];
+        let __v_92: G = __r_arr[23];
+        let __v_93: G = __r_arr[24];
+        let __v_94: G = __r_arr[25];
+        let __v_95: G = __r_arr[26];
+        let __v_96: G = __r_arr[27];
+        let __v_97: G = __r_arr[28];
+        let __v_98: G = __r_arr[29];
+        let __v_99: G = __r_arr[30];
+        let __v_100: G = __r_arr[31];
+        let __v_101: G = __r_arr[32];
+        let __v_102: G = __r_arr[33];
+        match __v_69.as_canonical_u64() {
+          0u64 => {
+            let __v_103: G = G::from_u64(1);
+            let __ret: [G; OUT_73] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_103: G = G::from_u64(4);
+            let __v_104: G = G::from_u64(8);
+            let __v_105: G = G::from_u64(103);
+            let __v_106: G = G::from_u64(230);
+            let __v_107: G = G::from_u64(9);
+            let __v_108: G = G::from_u64(106);
+            let __v_109: G = G::from_u64(133);
+            let __v_110: G = G::from_u64(174);
+            let __v_111: G = G::from_u64(103);
+            let __v_112: G = G::from_u64(187);
+            let __v_113: G = G::from_u64(114);
+            let __v_114: G = G::from_u64(243);
+            let __v_115: G = G::from_u64(110);
+            let __v_116: G = G::from_u64(60);
+            let __v_117: G = G::from_u64(58);
+            let __v_118: G = G::from_u64(245);
+            let __v_119: G = G::from_u64(79);
+            let __v_120: G = G::from_u64(165);
+            let __v_121: G = G::from_u64(127);
+            let __v_122: G = G::from_u64(82);
+            let __v_123: G = G::from_u64(14);
+            let __v_124: G = G::from_u64(81);
+            let __v_125: G = G::from_u64(140);
+            let __v_126: G = G::from_u64(104);
+            let __v_127: G = G::from_u64(5);
+            let __v_128: G = G::from_u64(155);
+            let __v_129: G = G::from_u64(171);
+            let __v_130: G = G::from_u64(217);
+            let __v_131: G = G::from_u64(131);
+            let __v_132: G = G::from_u64(31);
+            let __v_133: G = G::from_u64(25);
+            let __v_134: G = G::from_u64(205);
+            let __v_135: G = G::from_u64(224);
+            let __v_136: G = G::from_u64(91);
+            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+            let __v_137: G = __loaded[0];
+            let __v_138: G = __loaded[1];
+            let __v_139: G = __loaded[2];
+            let __v_140: G = __loaded[3];
+            let __v_141: G = __loaded[4];
+            let __v_142: G = __loaded[5];
+            let __v_143: G = __loaded[6];
+            let __v_144: G = __loaded[7];
+            let __v_145: G = __loaded[8];
+            let __v_146: G = __loaded[9];
+            let __v_147: G = __loaded[10];
+            let __v_148: G = __loaded[11];
+            let __v_149: G = __loaded[12];
+            let __v_150: G = __loaded[13];
+            let __v_151: G = __loaded[14];
+            let __v_152: G = __loaded[15];
+            let __v_153: G = __loaded[16];
+            let __v_154: G = __loaded[17];
+            let __v_155: G = __loaded[18];
+            let __v_156: G = __loaded[19];
+            let __v_157: G = __loaded[20];
+            let __v_158: G = __loaded[21];
+            let __v_159: G = __loaded[22];
+            let __v_160: G = __loaded[23];
+            let __v_161: G = __loaded[24];
+            let __v_162: G = __loaded[25];
+            let __v_163: G = __loaded[26];
+            let __v_164: G = __loaded[27];
+            let __v_165: G = __loaded[28];
+            let __v_166: G = __loaded[29];
+            let __v_167: G = __loaded[30];
+            let __v_168: G = __loaded[31];
+            let __v_169: G = __loaded[32];
+            let __v_170: G = __loaded[33];
+            match __v_137.as_canonical_u64() {
+              1u64 => {
+                let __v_171: G = (__v_104 * __v_33);
+                let __v_172: G = (__v_103 + __v_171);
+                let __v_173: G = G::from_u64(0);
+                let __v_174: G = G::from_u64(0);
+                let __v_175: G = G::from_u64(0);
+                let __v_176: G = G::from_u64(0);
+                let __v_177: G = G::from_u64(0);
+                let __v_178: G = G::from_u64(0);
+                let __v_179: G = G::from_u64(0);
+                let __v_180: G = G::from_u64(0);
+                let __v_181: G = G::from_u64(64);
+                let __v_182: G = G::from_u64(103);
+                let __v_183: G = G::from_u64(230);
+                let __v_184: G = G::from_u64(9);
+                let __v_185: G = G::from_u64(106);
+                let __v_186: G = G::from_u64(133);
+                let __v_187: G = G::from_u64(174);
+                let __v_188: G = G::from_u64(103);
+                let __v_189: G = G::from_u64(187);
+                let __v_190: G = G::from_u64(114);
+                let __v_191: G = G::from_u64(243);
+                let __v_192: G = G::from_u64(110);
+                let __v_193: G = G::from_u64(60);
+                let __v_194: G = G::from_u64(58);
+                let __v_195: G = G::from_u64(245);
+                let __v_196: G = G::from_u64(79);
+                let __v_197: G = G::from_u64(165);
+                let __v_198: G = G::from_u64(0);
+                let __v_199: G = G::from_u64(0);
+                let __v_200: G = G::from_u64(0);
+                let __v_201: G = G::from_u64(0);
+                let __v_202: G = G::from_u64(0);
+                let __v_203: G = G::from_u64(0);
+                let __v_204: G = G::from_u64(0);
+                let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+                let __v_205: G = __r_arr[0];
+                let __v_206: G = __r_arr[1];
+                let __v_207: G = __r_arr[2];
+                let __v_208: G = __r_arr[3];
+                let __v_209: G = __r_arr[4];
+                let __v_210: G = __r_arr[5];
+                let __v_211: G = __r_arr[6];
+                let __v_212: G = __r_arr[7];
+                let __v_213: G = __r_arr[8];
+                let __v_214: G = __r_arr[9];
+                let __v_215: G = __r_arr[10];
+                let __v_216: G = __r_arr[11];
+                let __v_217: G = __r_arr[12];
+                let __v_218: G = __r_arr[13];
+                let __v_219: G = __r_arr[14];
+                let __v_220: G = __r_arr[15];
+                let __v_221: G = __r_arr[16];
+                let __v_222: G = __r_arr[17];
+                let __v_223: G = __r_arr[18];
+                let __v_224: G = __r_arr[19];
+                let __v_225: G = __r_arr[20];
+                let __v_226: G = __r_arr[21];
+                let __v_227: G = __r_arr[22];
+                let __v_228: G = __r_arr[23];
+                let __v_229: G = __r_arr[24];
+                let __v_230: G = __r_arr[25];
+                let __v_231: G = __r_arr[26];
+                let __v_232: G = __r_arr[27];
+                let __v_233: G = __r_arr[28];
+                let __v_234: G = __r_arr[29];
+                let __v_235: G = __r_arr[30];
+                let __v_236: G = __r_arr[31];
+                let __v_237: G = G::from_u64(0);
+                let __v_238: G = G::from_u64(0);
+                let __v_239: G = G::from_u64(0);
+                let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_73] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
+                if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_171: G = G::from_u64(0);
+                let __v_172: G = G::from_u64(0);
+                let __v_173: G = G::from_u64(0);
+                let __v_174: G = G::from_u64(0);
+                let __v_175: G = G::from_u64(0);
+                let __v_176: G = G::from_u64(0);
+                let __v_177: G = G::from_u64(0);
+                let __v_178: G = G::from_u64(0);
+                let __v_179: G = G::from_u64(64);
+                let __v_180: G = G::from_u64(103);
+                let __v_181: G = G::from_u64(230);
+                let __v_182: G = G::from_u64(9);
+                let __v_183: G = G::from_u64(106);
+                let __v_184: G = G::from_u64(133);
+                let __v_185: G = G::from_u64(174);
+                let __v_186: G = G::from_u64(103);
+                let __v_187: G = G::from_u64(187);
+                let __v_188: G = G::from_u64(114);
+                let __v_189: G = G::from_u64(243);
+                let __v_190: G = G::from_u64(110);
+                let __v_191: G = G::from_u64(60);
+                let __v_192: G = G::from_u64(58);
+                let __v_193: G = G::from_u64(245);
+                let __v_194: G = G::from_u64(79);
+                let __v_195: G = G::from_u64(165);
+                let __v_196: G = G::from_u64(0);
+                let __v_197: G = G::from_u64(0);
+                let __v_198: G = G::from_u64(0);
+                let __v_199: G = G::from_u64(0);
+                let __v_200: G = G::from_u64(0);
+                let __v_201: G = G::from_u64(0);
+                let __v_202: G = G::from_u64(0);
+                let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+                let __v_203: G = __r_arr[0];
+                let __v_204: G = __r_arr[1];
+                let __v_205: G = __r_arr[2];
+                let __v_206: G = __r_arr[3];
+                let __v_207: G = __r_arr[4];
+                let __v_208: G = __r_arr[5];
+                let __v_209: G = __r_arr[6];
+                let __v_210: G = __r_arr[7];
+                let __v_211: G = __r_arr[8];
+                let __v_212: G = __r_arr[9];
+                let __v_213: G = __r_arr[10];
+                let __v_214: G = __r_arr[11];
+                let __v_215: G = __r_arr[12];
+                let __v_216: G = __r_arr[13];
+                let __v_217: G = __r_arr[14];
+                let __v_218: G = __r_arr[15];
+                let __v_219: G = __r_arr[16];
+                let __v_220: G = __r_arr[17];
+                let __v_221: G = __r_arr[18];
+                let __v_222: G = __r_arr[19];
+                let __v_223: G = __r_arr[20];
+                let __v_224: G = __r_arr[21];
+                let __v_225: G = __r_arr[22];
+                let __v_226: G = __r_arr[23];
+                let __v_227: G = __r_arr[24];
+                let __v_228: G = __r_arr[25];
+                let __v_229: G = __r_arr[26];
+                let __v_230: G = __r_arr[27];
+                let __v_231: G = __r_arr[28];
+                let __v_232: G = __r_arr[29];
+                let __v_233: G = __r_arr[30];
+                let __v_234: G = __r_arr[31];
+                let __v_235: G = G::from_u64(0);
+                let __v_236: G = G::from_u64(0);
+                let __v_237: G = G::from_u64(0);
+                let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_73] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
+                if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_74: usize = 1;
+const IN_74: usize = 1;
+const OUT_74: usize = 32;
+fn aiur_fn_74(
+  inp: [G; IN_74],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_74], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    let __v_11: G = __loaded[10];
+    let __v_12: G = __loaded[11];
+    let __v_13: G = __loaded[12];
+    let __v_14: G = __loaded[13];
+    let __v_15: G = __loaded[14];
+    let __v_16: G = __loaded[15];
+    let __v_17: G = __loaded[16];
+    let __v_18: G = __loaded[17];
+    let __v_19: G = __loaded[18];
+    let __v_20: G = __loaded[19];
+    let __v_21: G = __loaded[20];
+    let __v_22: G = __loaded[21];
+    let __v_23: G = __loaded[22];
+    let __v_24: G = __loaded[23];
+    let __v_25: G = __loaded[24];
+    let __v_26: G = __loaded[25];
+    let __v_27: G = __loaded[26];
+    let __v_28: G = __loaded[27];
+    let __v_29: G = __loaded[28];
+    let __v_30: G = __loaded[29];
+    let __v_31: G = __loaded[30];
+    let __v_32: G = __loaded[31];
+    let __v_33: G = __loaded[32];
+    let __v_34: G = __loaded[33];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __v_35: G = __loaded[0];
+        let __v_36: G = __loaded[1];
+        let __v_37: G = __loaded[2];
+        let __v_38: G = __loaded[3];
+        let __v_39: G = __loaded[4];
+        let __v_40: G = __loaded[5];
+        let __v_41: G = __loaded[6];
+        let __v_42: G = __loaded[7];
+        let __v_43: G = __loaded[8];
+        let __v_44: G = __loaded[9];
+        let __v_45: G = __loaded[10];
+        let __v_46: G = __loaded[11];
+        let __v_47: G = __loaded[12];
+        let __v_48: G = __loaded[13];
+        let __v_49: G = __loaded[14];
+        let __v_50: G = __loaded[15];
+        let __v_51: G = __loaded[16];
+        let __v_52: G = __loaded[17];
+        let __v_53: G = __loaded[18];
+        let __v_54: G = __loaded[19];
+        let __v_55: G = __loaded[20];
+        let __v_56: G = __loaded[21];
+        let __v_57: G = __loaded[22];
+        let __v_58: G = __loaded[23];
+        let __v_59: G = __loaded[24];
+        let __v_60: G = __loaded[25];
+        let __v_61: G = __loaded[26];
+        let __v_62: G = __loaded[27];
+        let __v_63: G = __loaded[28];
+        let __v_64: G = __loaded[29];
+        let __v_65: G = __loaded[30];
+        let __v_66: G = __loaded[31];
+        let __v_67: G = __loaded[32];
+        let __v_68: G = __loaded[33];
+        match __v_35.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_74] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34];
+            if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_69: G = G::from_u64(1);
+            let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+            let __v_70: G = __r_arr[0];
+            let __v_71: G = __r_arr[1];
+            let __v_72: G = __r_arr[2];
+            let __v_73: G = __r_arr[3];
+            let __v_74: G = __r_arr[4];
+            let __v_75: G = __r_arr[5];
+            let __v_76: G = __r_arr[6];
+            let __v_77: G = __r_arr[7];
+            let __v_78: G = __r_arr[8];
+            let __v_79: G = __r_arr[9];
+            let __v_80: G = __r_arr[10];
+            let __v_81: G = __r_arr[11];
+            let __v_82: G = __r_arr[12];
+            let __v_83: G = __r_arr[13];
+            let __v_84: G = __r_arr[14];
+            let __v_85: G = __r_arr[15];
+            let __v_86: G = __r_arr[16];
+            let __v_87: G = __r_arr[17];
+            let __v_88: G = __r_arr[18];
+            let __v_89: G = __r_arr[19];
+            let __v_90: G = __r_arr[20];
+            let __v_91: G = __r_arr[21];
+            let __v_92: G = __r_arr[22];
+            let __v_93: G = __r_arr[23];
+            let __v_94: G = __r_arr[24];
+            let __v_95: G = __r_arr[25];
+            let __v_96: G = __r_arr[26];
+            let __v_97: G = __r_arr[27];
+            let __v_98: G = __r_arr[28];
+            let __v_99: G = __r_arr[29];
+            let __v_100: G = __r_arr[30];
+            let __v_101: G = __r_arr[31];
+            let __v_102: G = __r_arr[32];
+            let __v_103: G = __r_arr[33];
+            match __v_70.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+                let __v_104: G = __r_arr[0];
+                let __v_105: G = __r_arr[1];
+                let __v_106: G = __r_arr[2];
+                let __v_107: G = __r_arr[3];
+                let __v_108: G = __r_arr[4];
+                let __v_109: G = __r_arr[5];
+                let __v_110: G = __r_arr[6];
+                let __v_111: G = __r_arr[7];
+                let __v_112: G = __r_arr[8];
+                let __v_113: G = __r_arr[9];
+                let __v_114: G = __r_arr[10];
+                let __v_115: G = __r_arr[11];
+                let __v_116: G = __r_arr[12];
+                let __v_117: G = __r_arr[13];
+                let __v_118: G = __r_arr[14];
+                let __v_119: G = __r_arr[15];
+                let __v_120: G = __r_arr[16];
+                let __v_121: G = __r_arr[17];
+                let __v_122: G = __r_arr[18];
+                let __v_123: G = __r_arr[19];
+                let __v_124: G = __r_arr[20];
+                let __v_125: G = __r_arr[21];
+                let __v_126: G = __r_arr[22];
+                let __v_127: G = __r_arr[23];
+                let __v_128: G = __r_arr[24];
+                let __v_129: G = __r_arr[25];
+                let __v_130: G = __r_arr[26];
+                let __v_131: G = __r_arr[27];
+                let __v_132: G = __r_arr[28];
+                let __v_133: G = __r_arr[29];
+                let __v_134: G = __r_arr[30];
+                let __v_135: G = __r_arr[31];
+                let __ret: [G; OUT_74] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135];
+                if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_104: G = G::from_u64(0);
+                let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+                let __v_106: G = __r_arr[0];
+                let __v_107: G = __r_arr[1];
+                let __v_108: G = __r_arr[2];
+                let __v_109: G = __r_arr[3];
+                let __v_110: G = __r_arr[4];
+                let __v_111: G = __r_arr[5];
+                let __v_112: G = __r_arr[6];
+                let __v_113: G = __r_arr[7];
+                let __v_114: G = __r_arr[8];
+                let __v_115: G = __r_arr[9];
+                let __v_116: G = __r_arr[10];
+                let __v_117: G = __r_arr[11];
+                let __v_118: G = __r_arr[12];
+                let __v_119: G = __r_arr[13];
+                let __v_120: G = __r_arr[14];
+                let __v_121: G = __r_arr[15];
+                let __v_122: G = __r_arr[16];
+                let __v_123: G = __r_arr[17];
+                let __v_124: G = __r_arr[18];
+                let __v_125: G = __r_arr[19];
+                let __v_126: G = __r_arr[20];
+                let __v_127: G = __r_arr[21];
+                let __v_128: G = __r_arr[22];
+                let __v_129: G = __r_arr[23];
+                let __v_130: G = __r_arr[24];
+                let __v_131: G = __r_arr[25];
+                let __v_132: G = __r_arr[26];
+                let __v_133: G = __r_arr[27];
+                let __v_134: G = __r_arr[28];
+                let __v_135: G = __r_arr[29];
+                let __v_136: G = __r_arr[30];
+                let __v_137: G = __r_arr[31];
+                let __ret: [G; OUT_74] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
+                if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_75: usize = 7;
+const IN_75: usize = 7;
+const OUT_75: usize = 1;
+fn aiur_fn_75(
+  inp: [G; IN_75],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_75], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_7: G = __loaded[0];
+    let __v_8: G = __loaded[1];
+    let __v_9: G = __loaded[2];
+    match __v_7.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __ret: [G; OUT_75] = [__v_10];
+        if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        match __v_2.as_canonical_u64() {
+          63u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_75] = [__v_12];
+            if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = (__v_2 + __v_12);
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = (__v_3 + __v_14);
+            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+            let __v_16: G = __r_arr[0];
+            let __ret: [G; OUT_75] = [__v_16];
+            if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_76: usize = 1;
+const IN_76: usize = 1;
+const OUT_76: usize = 64;
+fn aiur_fn_76(
+  inp: [G; IN_76],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_76], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_13: G = __loaded[0];
+                    let __v_14: G = __loaded[1];
+                    let __v_15: G = __loaded[2];
+                    match __v_13.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_16: G = __loaded[0];
+                        let __v_17: G = __loaded[1];
+                        let __v_18: G = __loaded[2];
+                        match __v_16.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_19: G = __loaded[0];
+                            let __v_20: G = __loaded[1];
+                            let __v_21: G = __loaded[2];
+                            match __v_19.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __v_25: G = __loaded[0];
+                                    let __v_26: G = __loaded[1];
+                                    let __v_27: G = __loaded[2];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __v_28: G = __loaded[0];
+                                        let __v_29: G = __loaded[1];
+                                        let __v_30: G = __loaded[2];
+                                        match __v_28.as_canonical_u64() {
+                                          0u64 => {
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __v_31: G = __loaded[0];
+                                            let __v_32: G = __loaded[1];
+                                            let __v_33: G = __loaded[2];
+                                            match __v_31.as_canonical_u64() {
+                                              0u64 => {
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __v_34: G = __loaded[0];
+                                                let __v_35: G = __loaded[1];
+                                                let __v_36: G = __loaded[2];
+                                                match __v_34.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __v_37: G = __loaded[0];
+                                                    let __v_38: G = __loaded[1];
+                                                    let __v_39: G = __loaded[2];
+                                                    match __v_37.as_canonical_u64() {
+                                                      0u64 => {
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __v_40: G = __loaded[0];
+                                                        let __v_41: G = __loaded[1];
+                                                        let __v_42: G = __loaded[2];
+                                                        match __v_40.as_canonical_u64() {
+                                                          0u64 => {
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __v_43: G = __loaded[0];
+                                                            let __v_44: G = __loaded[1];
+                                                            let __v_45: G = __loaded[2];
+                                                            match __v_43.as_canonical_u64() {
+                                                              0u64 => {
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __v_46: G = __loaded[0];
+                                                                let __v_47: G = __loaded[1];
+                                                                let __v_48: G = __loaded[2];
+                                                                match __v_46.as_canonical_u64() {
+                                                                  0u64 => {
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __v_49: G = __loaded[0];
+                                                                    let __v_50: G = __loaded[1];
+                                                                    let __v_51: G = __loaded[2];
+                                                                    match __v_49.as_canonical_u64() {
+                                                                      0u64 => {
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __v_52: G = __loaded[0];
+                                                                        let __v_53: G = __loaded[1];
+                                                                        let __v_54: G = __loaded[2];
+                                                                        match __v_52.as_canonical_u64() {
+                                                                          0u64 => {
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __v_55: G = __loaded[0];
+                                                                            let __v_56: G = __loaded[1];
+                                                                            let __v_57: G = __loaded[2];
+                                                                            match __v_55.as_canonical_u64() {
+                                                                              0u64 => {
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __v_58: G = __loaded[0];
+                                                                                let __v_59: G = __loaded[1];
+                                                                                let __v_60: G = __loaded[2];
+                                                                                match __v_58.as_canonical_u64() {
+                                                                                  0u64 => {
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __v_61: G = __loaded[0];
+                                                                                    let __v_62: G = __loaded[1];
+                                                                                    let __v_63: G = __loaded[2];
+                                                                                    match __v_61.as_canonical_u64() {
+                                                                                      0u64 => {
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __v_64: G = __loaded[0];
+                                                                                        let __v_65: G = __loaded[1];
+                                                                                        let __v_66: G = __loaded[2];
+                                                                                        match __v_64.as_canonical_u64() {
+                                                                                          0u64 => {
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __v_67: G = __loaded[0];
+                                                                                            let __v_68: G = __loaded[1];
+                                                                                            let __v_69: G = __loaded[2];
+                                                                                            match __v_67.as_canonical_u64() {
+                                                                                              0u64 => {
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __v_70: G = __loaded[0];
+                                                                                                let __v_71: G = __loaded[1];
+                                                                                                let __v_72: G = __loaded[2];
+                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                  0u64 => {
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __v_73: G = __loaded[0];
+                                                                                                    let __v_74: G = __loaded[1];
+                                                                                                    let __v_75: G = __loaded[2];
+                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                      0u64 => {
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __v_76: G = __loaded[0];
+                                                                                                        let __v_77: G = __loaded[1];
+                                                                                                        let __v_78: G = __loaded[2];
+                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                          0u64 => {
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __v_79: G = __loaded[0];
+                                                                                                            let __v_80: G = __loaded[1];
+                                                                                                            let __v_81: G = __loaded[2];
+                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                              0u64 => {
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __v_82: G = __loaded[0];
+                                                                                                                let __v_83: G = __loaded[1];
+                                                                                                                let __v_84: G = __loaded[2];
+                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                  0u64 => {
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __v_85: G = __loaded[0];
+                                                                                                                    let __v_86: G = __loaded[1];
+                                                                                                                    let __v_87: G = __loaded[2];
+                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                      0u64 => {
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __v_88: G = __loaded[0];
+                                                                                                                        let __v_89: G = __loaded[1];
+                                                                                                                        let __v_90: G = __loaded[2];
+                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                          0u64 => {
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                            let __v_93: G = __loaded[2];
+                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                              0u64 => {
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __v_94: G = __loaded[0];
+                                                                                                                                let __v_95: G = __loaded[1];
+                                                                                                                                let __v_96: G = __loaded[2];
+                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                  0u64 => {
+                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                    let __v_97: G = __loaded[0];
+                                                                                                                                    let __v_98: G = __loaded[1];
+                                                                                                                                    let __v_99: G = __loaded[2];
+                                                                                                                                    match __v_97.as_canonical_u64() {
+                                                                                                                                      0u64 => {
+                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                        let __v_100: G = __loaded[0];
+                                                                                                                                        let __v_101: G = __loaded[1];
+                                                                                                                                        let __v_102: G = __loaded[2];
+                                                                                                                                        match __v_100.as_canonical_u64() {
+                                                                                                                                          0u64 => {
+                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                            let __v_103: G = __loaded[0];
+                                                                                                                                            let __v_104: G = __loaded[1];
+                                                                                                                                            let __v_105: G = __loaded[2];
+                                                                                                                                            match __v_103.as_canonical_u64() {
+                                                                                                                                              0u64 => {
+                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                let __v_106: G = __loaded[0];
+                                                                                                                                                let __v_107: G = __loaded[1];
+                                                                                                                                                let __v_108: G = __loaded[2];
+                                                                                                                                                match __v_106.as_canonical_u64() {
+                                                                                                                                                  0u64 => {
+                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                    let __v_109: G = __loaded[0];
+                                                                                                                                                    let __v_110: G = __loaded[1];
+                                                                                                                                                    let __v_111: G = __loaded[2];
+                                                                                                                                                    match __v_109.as_canonical_u64() {
+                                                                                                                                                      0u64 => {
+                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                        let __v_112: G = __loaded[0];
+                                                                                                                                                        let __v_113: G = __loaded[1];
+                                                                                                                                                        let __v_114: G = __loaded[2];
+                                                                                                                                                        match __v_112.as_canonical_u64() {
+                                                                                                                                                          0u64 => {
+                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                            let __v_115: G = __loaded[0];
+                                                                                                                                                            let __v_116: G = __loaded[1];
+                                                                                                                                                            let __v_117: G = __loaded[2];
+                                                                                                                                                            match __v_115.as_canonical_u64() {
+                                                                                                                                                              0u64 => {
+                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                let __v_118: G = __loaded[0];
+                                                                                                                                                                let __v_119: G = __loaded[1];
+                                                                                                                                                                let __v_120: G = __loaded[2];
+                                                                                                                                                                match __v_118.as_canonical_u64() {
+                                                                                                                                                                  0u64 => {
+                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                    let __v_121: G = __loaded[0];
+                                                                                                                                                                    let __v_122: G = __loaded[1];
+                                                                                                                                                                    let __v_123: G = __loaded[2];
+                                                                                                                                                                    match __v_121.as_canonical_u64() {
+                                                                                                                                                                      0u64 => {
+                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                        let __v_124: G = __loaded[0];
+                                                                                                                                                                        let __v_125: G = __loaded[1];
+                                                                                                                                                                        let __v_126: G = __loaded[2];
+                                                                                                                                                                        match __v_124.as_canonical_u64() {
+                                                                                                                                                                          0u64 => {
+                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                            let __v_127: G = __loaded[0];
+                                                                                                                                                                            let __v_128: G = __loaded[1];
+                                                                                                                                                                            let __v_129: G = __loaded[2];
+                                                                                                                                                                            match __v_127.as_canonical_u64() {
+                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                let __v_130: G = __loaded[0];
+                                                                                                                                                                                let __v_131: G = __loaded[1];
+                                                                                                                                                                                let __v_132: G = __loaded[2];
+                                                                                                                                                                                match __v_130.as_canonical_u64() {
+                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                    let __v_133: G = __loaded[0];
+                                                                                                                                                                                    let __v_134: G = __loaded[1];
+                                                                                                                                                                                    let __v_135: G = __loaded[2];
+                                                                                                                                                                                    match __v_133.as_canonical_u64() {
+                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                        let __v_136: G = __loaded[0];
+                                                                                                                                                                                        let __v_137: G = __loaded[1];
+                                                                                                                                                                                        let __v_138: G = __loaded[2];
+                                                                                                                                                                                        match __v_136.as_canonical_u64() {
+                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                            let __v_139: G = __loaded[0];
+                                                                                                                                                                                            let __v_140: G = __loaded[1];
+                                                                                                                                                                                            let __v_141: G = __loaded[2];
+                                                                                                                                                                                            match __v_139.as_canonical_u64() {
+                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                let __v_142: G = __loaded[0];
+                                                                                                                                                                                                let __v_143: G = __loaded[1];
+                                                                                                                                                                                                let __v_144: G = __loaded[2];
+                                                                                                                                                                                                match __v_142.as_canonical_u64() {
+                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                    let __v_145: G = __loaded[0];
+                                                                                                                                                                                                    let __v_146: G = __loaded[1];
+                                                                                                                                                                                                    let __v_147: G = __loaded[2];
+                                                                                                                                                                                                    match __v_145.as_canonical_u64() {
+                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                        let __v_148: G = __loaded[0];
+                                                                                                                                                                                                        let __v_149: G = __loaded[1];
+                                                                                                                                                                                                        let __v_150: G = __loaded[2];
+                                                                                                                                                                                                        match __v_148.as_canonical_u64() {
+                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                            let __v_151: G = __loaded[0];
+                                                                                                                                                                                                            let __v_152: G = __loaded[1];
+                                                                                                                                                                                                            let __v_153: G = __loaded[2];
+                                                                                                                                                                                                            match __v_151.as_canonical_u64() {
+                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                let __v_154: G = __loaded[0];
+                                                                                                                                                                                                                let __v_155: G = __loaded[1];
+                                                                                                                                                                                                                let __v_156: G = __loaded[2];
+                                                                                                                                                                                                                match __v_154.as_canonical_u64() {
+                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                    let __v_157: G = __loaded[0];
+                                                                                                                                                                                                                    let __v_158: G = __loaded[1];
+                                                                                                                                                                                                                    let __v_159: G = __loaded[2];
+                                                                                                                                                                                                                    match __v_157.as_canonical_u64() {
+                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                        let __v_160: G = __loaded[0];
+                                                                                                                                                                                                                        let __v_161: G = __loaded[1];
+                                                                                                                                                                                                                        let __v_162: G = __loaded[2];
+                                                                                                                                                                                                                        match __v_160.as_canonical_u64() {
+                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                            let __v_163: G = __loaded[0];
+                                                                                                                                                                                                                            let __v_164: G = __loaded[1];
+                                                                                                                                                                                                                            let __v_165: G = __loaded[2];
+                                                                                                                                                                                                                            match __v_163.as_canonical_u64() {
+                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                let __v_166: G = __loaded[0];
+                                                                                                                                                                                                                                let __v_167: G = __loaded[1];
+                                                                                                                                                                                                                                let __v_168: G = __loaded[2];
+                                                                                                                                                                                                                                match __v_166.as_canonical_u64() {
+                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                    let __v_169: G = __loaded[0];
+                                                                                                                                                                                                                                    let __v_170: G = __loaded[1];
+                                                                                                                                                                                                                                    let __v_171: G = __loaded[2];
+                                                                                                                                                                                                                                    match __v_169.as_canonical_u64() {
+                                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                        let __v_172: G = __loaded[0];
+                                                                                                                                                                                                                                        let __v_173: G = __loaded[1];
+                                                                                                                                                                                                                                        let __v_174: G = __loaded[2];
+                                                                                                                                                                                                                                        match __v_172.as_canonical_u64() {
+                                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                            let __v_175: G = __loaded[0];
+                                                                                                                                                                                                                                            let __v_176: G = __loaded[1];
+                                                                                                                                                                                                                                            let __v_177: G = __loaded[2];
+                                                                                                                                                                                                                                            match __v_175.as_canonical_u64() {
+                                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                let __v_178: G = __loaded[0];
+                                                                                                                                                                                                                                                let __v_179: G = __loaded[1];
+                                                                                                                                                                                                                                                let __v_180: G = __loaded[2];
+                                                                                                                                                                                                                                                match __v_178.as_canonical_u64() {
+                                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                    let __v_181: G = __loaded[0];
+                                                                                                                                                                                                                                                    let __v_182: G = __loaded[1];
+                                                                                                                                                                                                                                                    let __v_183: G = __loaded[2];
+                                                                                                                                                                                                                                                    match __v_181.as_canonical_u64() {
+                                                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                        let __v_184: G = __loaded[0];
+                                                                                                                                                                                                                                                        let __v_185: G = __loaded[1];
+                                                                                                                                                                                                                                                        let __v_186: G = __loaded[2];
+                                                                                                                                                                                                                                                        match __v_184.as_canonical_u64() {
+                                                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                            let __v_187: G = __loaded[0];
+                                                                                                                                                                                                                                                            let __v_188: G = __loaded[1];
+                                                                                                                                                                                                                                                            let __v_189: G = __loaded[2];
+                                                                                                                                                                                                                                                            match __v_187.as_canonical_u64() {
+                                                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                let __v_190: G = __loaded[0];
+                                                                                                                                                                                                                                                                let __v_191: G = __loaded[1];
+                                                                                                                                                                                                                                                                let __v_192: G = __loaded[2];
+                                                                                                                                                                                                                                                                match __v_190.as_canonical_u64() {
+                                                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_76] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
+                                                                                                                                                                                                                                                                    if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64()));
+                                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64()));
+                                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64()));
+                                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64()));
+                                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64()));
+                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64()));
+                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64()));
+                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64()));
+                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64()));
+                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64()));
+                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64()));
+                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64()));
+                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64()));
+                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                }
+                                                                                                                                                                                                              },
+                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64()));
+                                                                                                                                                                                                              },
+                                                                                                                                                                                                            }
+                                                                                                                                                                                                          },
+                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64()));
+                                                                                                                                                                                                          },
+                                                                                                                                                                                                        }
+                                                                                                                                                                                                      },
+                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64()));
+                                                                                                                                                                                                      },
+                                                                                                                                                                                                    }
+                                                                                                                                                                                                  },
+                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64()));
+                                                                                                                                                                                                  },
+                                                                                                                                                                                                }
+                                                                                                                                                                                              },
+                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64()));
+                                                                                                                                                                                              },
+                                                                                                                                                                                            }
+                                                                                                                                                                                          },
+                                                                                                                                                                                          _ => {
+                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64()));
+                                                                                                                                                                                          },
+                                                                                                                                                                                        }
+                                                                                                                                                                                      },
+                                                                                                                                                                                      _ => {
+                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64()));
+                                                                                                                                                                                      },
+                                                                                                                                                                                    }
+                                                                                                                                                                                  },
+                                                                                                                                                                                  _ => {
+                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64()));
+                                                                                                                                                                                  },
+                                                                                                                                                                                }
+                                                                                                                                                                              },
+                                                                                                                                                                              _ => {
+                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64()));
+                                                                                                                                                                              },
+                                                                                                                                                                            }
+                                                                                                                                                                          },
+                                                                                                                                                                          _ => {
+                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
+                                                                                                                                                                          },
+                                                                                                                                                                        }
+                                                                                                                                                                      },
+                                                                                                                                                                      _ => {
+                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
+                                                                                                                                                                      },
+                                                                                                                                                                    }
+                                                                                                                                                                  },
+                                                                                                                                                                  _ => {
+                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
+                                                                                                                                                                  },
+                                                                                                                                                                }
+                                                                                                                                                              },
+                                                                                                                                                              _ => {
+                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
+                                                                                                                                                              },
+                                                                                                                                                            }
+                                                                                                                                                          },
+                                                                                                                                                          _ => {
+                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
+                                                                                                                                                          },
+                                                                                                                                                        }
+                                                                                                                                                      },
+                                                                                                                                                      _ => {
+                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
+                                                                                                                                                      },
+                                                                                                                                                    }
+                                                                                                                                                  },
+                                                                                                                                                  _ => {
+                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
+                                                                                                                                                  },
+                                                                                                                                                }
+                                                                                                                                              },
+                                                                                                                                              _ => {
+                                                                                                                                                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+                                                                                                                                              },
+                                                                                                                                            }
+                                                                                                                                          },
+                                                                                                                                          _ => {
+                                                                                                                                            return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64()));
+                                                                                                                                          },
+                                                                                                                                        }
+                                                                                                                                      },
+                                                                                                                                      _ => {
+                                                                                                                                        return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64()));
+                                                                                                                                      },
+                                                                                                                                    }
+                                                                                                                                  },
+                                                                                                                                  _ => {
+                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
+                                                                                                                                  },
+                                                                                                                                }
+                                                                                                                              },
+                                                                                                                              _ => {
+                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
+                                                                                                                              },
+                                                                                                                            }
+                                                                                                                          },
+                                                                                                                          _ => {
+                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
+                                                                                                                          },
+                                                                                                                        }
+                                                                                                                      },
+                                                                                                                      _ => {
+                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
+                                                                                                                      },
+                                                                                                                    }
+                                                                                                                  },
+                                                                                                                  _ => {
+                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
+                                                                                                                  },
+                                                                                                                }
+                                                                                                              },
+                                                                                                              _ => {
+                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
+                                                                                                              },
+                                                                                                            }
+                                                                                                          },
+                                                                                                          _ => {
+                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
+                                                                                                          },
+                                                                                                        }
+                                                                                                      },
+                                                                                                      _ => {
+                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
+                                                                                                      },
+                                                                                                    }
+                                                                                                  },
+                                                                                                  _ => {
+                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
+                                                                                                  },
+                                                                                                }
+                                                                                              },
+                                                                                              _ => {
+                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
+                                                                                              },
+                                                                                            }
+                                                                                          },
+                                                                                          _ => {
+                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
+                                                                                          },
+                                                                                        }
+                                                                                      },
+                                                                                      _ => {
+                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
+                                                                                      },
+                                                                                    }
+                                                                                  },
+                                                                                  _ => {
+                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
+                                                                                  },
+                                                                                }
+                                                                              },
+                                                                              _ => {
+                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+                                                                              },
+                                                                            }
+                                                                          },
+                                                                          _ => {
+                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
+                                                                          },
+                                                                        }
+                                                                      },
+                                                                      _ => {
+                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
+                                                                      },
+                                                                    }
+                                                                  },
+                                                                  _ => {
+                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
+                                                                  },
+                                                                }
+                                                              },
+                                                              _ => {
+                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
+                                                              },
+                                                            }
+                                                          },
+                                                          _ => {
+                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
+                                                          },
+                                                        }
+                                                      },
+                                                      _ => {
+                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
+                                                      },
+                                                    }
+                                                  },
+                                                  _ => {
+                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+                                                  },
+                                                }
+                                              },
+                                              _ => {
+                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+                                              },
+                                            }
+                                          },
+                                          _ => {
+                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                          },
                         }
-                        let __v_225: G = G::from_u64(1);
-                        let __v_226: G = G::from_u64(1);
-                        let __v_227: G = { let __values: [G; 10] = [__v_225, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_228: G = { let __values: [G; 10] = [__v_197, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_227]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_229: G = { let __values: [G; 10] = [__v_169, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_230: G = { let __values: [G; 10] = [__v_141, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_231: G = { let __values: [G; 10] = [__v_113, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_232: G = G::from_u64(1);
-                        let __v_233: G = G::from_u64(1);
-                        let __v_234: G = { let __values: [G; 3] = [__v_232, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_235: G = { let __values: [G; 3] = [__v_112, __v_231, __v_234]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_236: G = G::from_u64(0);
-                        let __v_237: G = G::from_u64(1);
-                        let __v_238: G = G::from_u64(1);
-                        let __v_239: G = { let __values: [G; 3] = [__v_237, __v_238, __v_238]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_240: G = { let __values: [G; 3] = [__v_236, __v_25, __v_239]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-                        let __v_241: G = __r_arr[0];
-                        let __v_242: G = G::from_u64(1);
-                        if (__v_241 != __v_242) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: None });
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_77: usize = 2;
+const IN_77: usize = 2;
+const OUT_77: usize = 1;
+fn aiur_fn_77(
+  inp: [G; IN_77],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_77], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_77] = [__v_0];
+        if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 - __v_5);
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_77] = [__v_7];
+        if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_78: usize = 6;
+const IN_78: usize = 6;
+const OUT_78: usize = 1;
+fn aiur_fn_78(
+  inp: [G; IN_78],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_78], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = G::from_u64(1);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(8);
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __v_9: G = __loaded[0];
+            let __v_10: G = __loaded[1];
+            let __v_11: G = __loaded[2];
+            let __v_12: G = __loaded[3];
+            let __v_13: G = __loaded[4];
+            let __v_14: G = __loaded[5];
+            let __v_15: G = __loaded[6];
+            let __v_16: G = __loaded[7];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    match __v_11.as_canonical_u64() {
+                      0u64 => {
+                        match __v_12.as_canonical_u64() {
+                          0u64 => {
+                            match __v_13.as_canonical_u64() {
+                              0u64 => {
+                                match __v_14.as_canonical_u64() {
+                                  0u64 => {
+                                    match __v_15.as_canonical_u64() {
+                                      0u64 => {
+                                        match __v_16.as_canonical_u64() {
+                                          0u64 => {
+                                            let __v_17: G = (__v_6 + __v_7);
+                                            let __v_18: G = (__v_8 + __v_17);
+                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                            let __v_19: G = __loaded[0];
+                                            let __v_20: G = __loaded[1];
+                                            let __v_21: G = __loaded[2];
+                                            let __v_22: G = __loaded[3];
+                                            let __v_23: G = __loaded[4];
+                                            let __v_24: G = __loaded[5];
+                                            let __v_25: G = __loaded[6];
+                                            let __v_26: G = __loaded[7];
+                                            let __v_27: G = __loaded[8];
+                                            let __v_28: G = __loaded[9];
+                                            let __v_29: G = __loaded[10];
+                                            let __v_30: G = __loaded[11];
+                                            let __v_31: G = __loaded[12];
+                                            let __v_32: G = __loaded[13];
+                                            let __v_33: G = __loaded[14];
+                                            let __v_34: G = __loaded[15];
+                                            let __v_35: G = __loaded[16];
+                                            let __v_36: G = __loaded[17];
+                                            let __v_37: G = __loaded[18];
+                                            let __v_38: G = __loaded[19];
+                                            let __v_39: G = __loaded[20];
+                                            let __v_40: G = __loaded[21];
+                                            let __v_41: G = __loaded[22];
+                                            let __v_42: G = __loaded[23];
+                                            let __v_43: G = __loaded[24];
+                                            let __v_44: G = __loaded[25];
+                                            let __v_45: G = __loaded[26];
+                                            let __v_46: G = __loaded[27];
+                                            let __v_47: G = __loaded[28];
+                                            let __v_48: G = __loaded[29];
+                                            let __v_49: G = __loaded[30];
+                                            let __v_50: G = __loaded[31];
+                                            let __v_51: G = G::from_u64(0);
+                                            let __v_52: G = G::from_u64(0);
+                                            let __v_53: G = G::from_u64(0);
+                                            let __v_54: G = G::from_u64(0);
+                                            let __v_55: G = G::from_u64(0);
+                                            let __v_56: G = G::from_u64(0);
+                                            let __v_57: G = G::from_u64(0);
+                                            let __v_58: G = G::from_u64(0);
+                                            let __v_59: G = G::from_u64(0);
+                                            let __v_60: G = G::from_u64(0);
+                                            let __v_61: G = G::from_u64(0);
+                                            let __v_62: G = G::from_u64(0);
+                                            let __v_63: G = G::from_u64(0);
+                                            let __v_64: G = G::from_u64(0);
+                                            let __v_65: G = G::from_u64(0);
+                                            let __v_66: G = G::from_u64(0);
+                                            let __v_67: G = G::from_u64(0);
+                                            let __v_68: G = G::from_u64(0);
+                                            let __v_69: G = G::from_u64(0);
+                                            let __v_70: G = G::from_u64(0);
+                                            let __v_71: G = G::from_u64(0);
+                                            let __v_72: G = G::from_u64(0);
+                                            let __v_73: G = G::from_u64(0);
+                                            let __v_74: G = G::from_u64(0);
+                                            let __v_75: G = G::from_u64(0);
+                                            let __v_76: G = G::from_u64(0);
+                                            let __v_77: G = G::from_u64(0);
+                                            let __v_78: G = G::from_u64(0);
+                                            let __v_79: G = G::from_u64(0);
+                                            let __v_80: G = G::from_u64(0);
+                                            let __v_81: G = G::from_u64(0);
+                                            let __v_82: G = G::from_u64(0);
+                                            let __v_83: G = G::from_u64(0);
+                                            let __v_84: G = G::from_u64(0);
+                                            let __v_85: G = G::from_u64(0);
+                                            let __v_86: G = G::from_u64(0);
+                                            let __v_87: G = G::from_u64(0);
+                                            let __v_88: G = G::from_u64(0);
+                                            let __v_89: G = G::from_u64(0);
+                                            let __v_90: G = G::from_u64(0);
+                                            let __v_91: G = G::from_u64(0);
+                                            let __v_92: G = G::from_u64(0);
+                                            let __v_93: G = G::from_u64(0);
+                                            let __v_94: G = G::from_u64(0);
+                                            let __v_95: G = G::from_u64(0);
+                                            let __v_96: G = G::from_u64(0);
+                                            let __v_97: G = G::from_u64(0);
+                                            let __v_98: G = G::from_u64(0);
+                                            let __v_99: G = G::from_u64(0);
+                                            let __v_100: G = G::from_u64(0);
+                                            let __v_101: G = G::from_u64(0);
+                                            let __v_102: G = G::from_u64(0);
+                                            let __v_103: G = G::from_u64(0);
+                                            let __v_104: G = G::from_u64(0);
+                                            let __v_105: G = G::from_u64(0);
+                                            let __v_106: G = G::from_u64(0);
+                                            let __v_107: G = G::from_u64(0);
+                                            let __v_108: G = G::from_u64(0);
+                                            let __v_109: G = G::from_u64(0);
+                                            let __v_110: G = G::from_u64(0);
+                                            let __v_111: G = G::from_u64(0);
+                                            let __v_112: G = G::from_u64(0);
+                                            let __v_113: G = G::from_u64(0);
+                                            let __v_114: G = G::from_u64(0);
+                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                            let __v_115: G = __loaded[0];
+                                            let __v_116: G = __loaded[1];
+                                            let __v_117: G = __loaded[2];
+                                            let __v_118: G = __loaded[3];
+                                            let __v_119: G = __loaded[4];
+                                            let __v_120: G = __loaded[5];
+                                            let __v_121: G = __loaded[6];
+                                            let __v_122: G = __loaded[7];
+                                            let __v_123: G = G::from_u64(0);
+                                            let __v_124: G = G::from_u64(103);
+                                            let __v_125: G = G::from_u64(230);
+                                            let __v_126: G = G::from_u64(9);
+                                            let __v_127: G = G::from_u64(106);
+                                            let __v_128: G = G::from_u64(133);
+                                            let __v_129: G = G::from_u64(174);
+                                            let __v_130: G = G::from_u64(103);
+                                            let __v_131: G = G::from_u64(187);
+                                            let __v_132: G = G::from_u64(114);
+                                            let __v_133: G = G::from_u64(243);
+                                            let __v_134: G = G::from_u64(110);
+                                            let __v_135: G = G::from_u64(60);
+                                            let __v_136: G = G::from_u64(58);
+                                            let __v_137: G = G::from_u64(245);
+                                            let __v_138: G = G::from_u64(79);
+                                            let __v_139: G = G::from_u64(165);
+                                            let __v_140: G = G::from_u64(0);
+                                            let __v_141: G = G::from_u64(0);
+                                            let __v_142: G = G::from_u64(0);
+                                            let __v_143: G = G::from_u64(0);
+                                            let __v_144: G = G::from_u64(0);
+                                            let __v_145: G = G::from_u64(0);
+                                            let __v_146: G = G::from_u64(0);
+                                            let __v_147: G = G::from_u64(0);
+                                            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+                                            let __v_148: G = __r_arr[0];
+                                            let __v_149: G = __r_arr[1];
+                                            let __v_150: G = __r_arr[2];
+                                            let __v_151: G = __r_arr[3];
+                                            let __v_152: G = __r_arr[4];
+                                            let __v_153: G = __r_arr[5];
+                                            let __v_154: G = __r_arr[6];
+                                            let __v_155: G = __r_arr[7];
+                                            let __v_156: G = __r_arr[8];
+                                            let __v_157: G = __r_arr[9];
+                                            let __v_158: G = __r_arr[10];
+                                            let __v_159: G = __r_arr[11];
+                                            let __v_160: G = __r_arr[12];
+                                            let __v_161: G = __r_arr[13];
+                                            let __v_162: G = __r_arr[14];
+                                            let __v_163: G = __r_arr[15];
+                                            let __v_164: G = __r_arr[16];
+                                            let __v_165: G = __r_arr[17];
+                                            let __v_166: G = __r_arr[18];
+                                            let __v_167: G = __r_arr[19];
+                                            let __v_168: G = __r_arr[20];
+                                            let __v_169: G = __r_arr[21];
+                                            let __v_170: G = __r_arr[22];
+                                            let __v_171: G = __r_arr[23];
+                                            let __v_172: G = __r_arr[24];
+                                            let __v_173: G = __r_arr[25];
+                                            let __v_174: G = __r_arr[26];
+                                            let __v_175: G = __r_arr[27];
+                                            let __v_176: G = __r_arr[28];
+                                            let __v_177: G = __r_arr[29];
+                                            let __v_178: G = __r_arr[30];
+                                            let __v_179: G = __r_arr[31];
+                                            let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_78] = [__v_180];
+                                            if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __ret: [G; OUT_78] = [__v_5];
+                                            if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            return Ok(__ret);
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_78] = [__v_5];
+                                        if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_78] = [__v_5];
+                                    if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_78] = [__v_5];
+                                if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_78] = [__v_5];
+                            if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            return Ok(__ret);
+                          },
                         }
-                        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_107, __v_108, __v_17, __v_20, __v_13, __v_23, __v_25, __v_109, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
-                        let __v_243: G = __r_arr[0];
-                        let __v_244: G = __r_arr[1];
-                        let __ret: [G; OUT_140] = [__v_243, __v_244];
-                        if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                        return Ok(__ret);
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+                        let __ret: [G; OUT_78] = [__v_5];
+                        if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        return Ok(__ret);
                       },
                     }
                   },
+                  _ => {
+                    let __ret: [G; OUT_78] = [__v_5];
+                    if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    return Ok(__ret);
+                  },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+                let __ret: [G; OUT_78] = [__v_5];
+                if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+            let __v_9: G = G::from_u64(0);
+            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            let __v_13: G = __loaded[3];
+            let __v_14: G = __loaded[4];
+            let __v_15: G = __loaded[5];
+            let __v_16: G = __loaded[6];
+            let __v_17: G = __loaded[7];
+            let __v_18: G = __loaded[8];
+            let __v_19: G = __loaded[9];
+            let __v_20: G = __loaded[10];
+            let __v_21: G = __loaded[11];
+            let __v_22: G = __loaded[12];
+            let __v_23: G = __loaded[13];
+            let __v_24: G = __loaded[14];
+            let __v_25: G = __loaded[15];
+            let __v_26: G = __loaded[16];
+            let __v_27: G = __loaded[17];
+            let __v_28: G = __loaded[18];
+            let __v_29: G = __loaded[19];
+            let __v_30: G = __loaded[20];
+            let __v_31: G = __loaded[21];
+            let __v_32: G = __loaded[22];
+            let __v_33: G = __loaded[23];
+            let __v_34: G = __loaded[24];
+            let __v_35: G = __loaded[25];
+            let __v_36: G = __loaded[26];
+            let __v_37: G = __loaded[27];
+            let __v_38: G = __loaded[28];
+            let __v_39: G = __loaded[29];
+            let __v_40: G = __loaded[30];
+            let __v_41: G = __loaded[31];
+            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_78] = [__v_42];
+            if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        let __v_13: G = __loaded[4];
+        let __v_14: G = __loaded[5];
+        let __v_15: G = __loaded[6];
+        let __v_16: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __v_18: G = (__v_17 * __v_8);
+        let __v_19: G = (__v_2 - __v_1);
+        let __v_20: G = G::from_bool((__v_19 == G::ZERO));
+        let __v_21: G = (__v_20 * __v_6);
+        let __v_22: G = (__v_18 + __v_21);
+        let __v_23: G = (__v_7 + __v_22);
+        let __v_24: G = G::from_u64(64);
+        let __v_25: G = (__v_24 - __v_1);
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+        let __v_26: G = __r_arr[0];
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __v_28: G = __r_arr[1];
+        let __v_29: G = __r_arr[2];
+        let __v_30: G = __r_arr[3];
+        let __v_31: G = __r_arr[4];
+        let __v_32: G = __r_arr[5];
+        let __v_33: G = __r_arr[6];
+        let __v_34: G = __r_arr[7];
+        let __v_35: G = __r_arr[8];
+        let __v_36: G = __r_arr[9];
+        let __v_37: G = __r_arr[10];
+        let __v_38: G = __r_arr[11];
+        let __v_39: G = __r_arr[12];
+        let __v_40: G = __r_arr[13];
+        let __v_41: G = __r_arr[14];
+        let __v_42: G = __r_arr[15];
+        let __v_43: G = __r_arr[16];
+        let __v_44: G = __r_arr[17];
+        let __v_45: G = __r_arr[18];
+        let __v_46: G = __r_arr[19];
+        let __v_47: G = __r_arr[20];
+        let __v_48: G = __r_arr[21];
+        let __v_49: G = __r_arr[22];
+        let __v_50: G = __r_arr[23];
+        let __v_51: G = __r_arr[24];
+        let __v_52: G = __r_arr[25];
+        let __v_53: G = __r_arr[26];
+        let __v_54: G = __r_arr[27];
+        let __v_55: G = __r_arr[28];
+        let __v_56: G = __r_arr[29];
+        let __v_57: G = __r_arr[30];
+        let __v_58: G = __r_arr[31];
+        let __v_59: G = __r_arr[32];
+        let __v_60: G = __r_arr[33];
+        let __v_61: G = __r_arr[34];
+        let __v_62: G = __r_arr[35];
+        let __v_63: G = __r_arr[36];
+        let __v_64: G = __r_arr[37];
+        let __v_65: G = __r_arr[38];
+        let __v_66: G = __r_arr[39];
+        let __v_67: G = __r_arr[40];
+        let __v_68: G = __r_arr[41];
+        let __v_69: G = __r_arr[42];
+        let __v_70: G = __r_arr[43];
+        let __v_71: G = __r_arr[44];
+        let __v_72: G = __r_arr[45];
+        let __v_73: G = __r_arr[46];
+        let __v_74: G = __r_arr[47];
+        let __v_75: G = __r_arr[48];
+        let __v_76: G = __r_arr[49];
+        let __v_77: G = __r_arr[50];
+        let __v_78: G = __r_arr[51];
+        let __v_79: G = __r_arr[52];
+        let __v_80: G = __r_arr[53];
+        let __v_81: G = __r_arr[54];
+        let __v_82: G = __r_arr[55];
+        let __v_83: G = __r_arr[56];
+        let __v_84: G = __r_arr[57];
+        let __v_85: G = __r_arr[58];
+        let __v_86: G = __r_arr[59];
+        let __v_87: G = __r_arr[60];
+        let __v_88: G = __r_arr[61];
+        let __v_89: G = __r_arr[62];
+        let __v_90: G = __r_arr[63];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_91: G = __loaded[0];
+        let __v_92: G = __loaded[1];
+        let __v_93: G = __loaded[2];
+        let __v_94: G = __loaded[3];
+        let __v_95: G = __loaded[4];
+        let __v_96: G = __loaded[5];
+        let __v_97: G = __loaded[6];
+        let __v_98: G = __loaded[7];
+        let __v_99: G = __loaded[8];
+        let __v_100: G = __loaded[9];
+        let __v_101: G = __loaded[10];
+        let __v_102: G = __loaded[11];
+        let __v_103: G = __loaded[12];
+        let __v_104: G = __loaded[13];
+        let __v_105: G = __loaded[14];
+        let __v_106: G = __loaded[15];
+        let __v_107: G = __loaded[16];
+        let __v_108: G = __loaded[17];
+        let __v_109: G = __loaded[18];
+        let __v_110: G = __loaded[19];
+        let __v_111: G = __loaded[20];
+        let __v_112: G = __loaded[21];
+        let __v_113: G = __loaded[22];
+        let __v_114: G = __loaded[23];
+        let __v_115: G = __loaded[24];
+        let __v_116: G = __loaded[25];
+        let __v_117: G = __loaded[26];
+        let __v_118: G = __loaded[27];
+        let __v_119: G = __loaded[28];
+        let __v_120: G = __loaded[29];
+        let __v_121: G = __loaded[30];
+        let __v_122: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_123: G = __loaded[0];
+        let __v_124: G = __loaded[1];
+        let __v_125: G = __loaded[2];
+        let __v_126: G = __loaded[3];
+        let __v_127: G = __loaded[4];
+        let __v_128: G = __loaded[5];
+        let __v_129: G = __loaded[6];
+        let __v_130: G = __loaded[7];
+        let __v_131: G = G::from_u64(103);
+        let __v_132: G = G::from_u64(230);
+        let __v_133: G = G::from_u64(9);
+        let __v_134: G = G::from_u64(106);
+        let __v_135: G = G::from_u64(133);
+        let __v_136: G = G::from_u64(174);
+        let __v_137: G = G::from_u64(103);
+        let __v_138: G = G::from_u64(187);
+        let __v_139: G = G::from_u64(114);
+        let __v_140: G = G::from_u64(243);
+        let __v_141: G = G::from_u64(110);
+        let __v_142: G = G::from_u64(60);
+        let __v_143: G = G::from_u64(58);
+        let __v_144: G = G::from_u64(245);
+        let __v_145: G = G::from_u64(79);
+        let __v_146: G = G::from_u64(165);
+        let __v_147: G = G::from_u64(0);
+        let __v_148: G = G::from_u64(0);
+        let __v_149: G = G::from_u64(0);
+        let __v_150: G = G::from_u64(0);
+        let __v_151: G = G::from_u64(0);
+        let __v_152: G = G::from_u64(0);
+        let __v_153: G = G::from_u64(0);
+        let __v_154: G = G::from_u64(0);
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __v_155: G = __r_arr[0];
+        let __v_156: G = __r_arr[1];
+        let __v_157: G = __r_arr[2];
+        let __v_158: G = __r_arr[3];
+        let __v_159: G = __r_arr[4];
+        let __v_160: G = __r_arr[5];
+        let __v_161: G = __r_arr[6];
+        let __v_162: G = __r_arr[7];
+        let __v_163: G = __r_arr[8];
+        let __v_164: G = __r_arr[9];
+        let __v_165: G = __r_arr[10];
+        let __v_166: G = __r_arr[11];
+        let __v_167: G = __r_arr[12];
+        let __v_168: G = __r_arr[13];
+        let __v_169: G = __r_arr[14];
+        let __v_170: G = __r_arr[15];
+        let __v_171: G = __r_arr[16];
+        let __v_172: G = __r_arr[17];
+        let __v_173: G = __r_arr[18];
+        let __v_174: G = __r_arr[19];
+        let __v_175: G = __r_arr[20];
+        let __v_176: G = __r_arr[21];
+        let __v_177: G = __r_arr[22];
+        let __v_178: G = __r_arr[23];
+        let __v_179: G = __r_arr[24];
+        let __v_180: G = __r_arr[25];
+        let __v_181: G = __r_arr[26];
+        let __v_182: G = __r_arr[27];
+        let __v_183: G = __r_arr[28];
+        let __v_184: G = __r_arr[29];
+        let __v_185: G = __r_arr[30];
+        let __v_186: G = __r_arr[31];
+        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_78] = [__v_187];
+        if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_79: usize = 6;
+const IN_79: usize = 6;
+const OUT_79: usize = 1;
+fn aiur_fn_79(
+  inp: [G; IN_79],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_79], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = G::from_u64(1);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(8);
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __v_11: G = __r_arr[2];
+    let __v_12: G = __r_arr[3];
+    let __v_13: G = __r_arr[4];
+    let __v_14: G = __r_arr[5];
+    let __v_15: G = __r_arr[6];
+    let __v_16: G = __r_arr[7];
+    let __v_17: G = __r_arr[8];
+    let __v_18: G = __r_arr[9];
+    let __v_19: G = __r_arr[10];
+    let __v_20: G = __r_arr[11];
+    let __v_21: G = __r_arr[12];
+    let __v_22: G = __r_arr[13];
+    let __v_23: G = __r_arr[14];
+    let __v_24: G = __r_arr[15];
+    let __v_25: G = __r_arr[16];
+    let __v_26: G = __r_arr[17];
+    let __v_27: G = __r_arr[18];
+    let __v_28: G = __r_arr[19];
+    let __v_29: G = __r_arr[20];
+    let __v_30: G = __r_arr[21];
+    let __v_31: G = __r_arr[22];
+    let __v_32: G = __r_arr[23];
+    let __v_33: G = __r_arr[24];
+    let __v_34: G = __r_arr[25];
+    let __v_35: G = __r_arr[26];
+    let __v_36: G = __r_arr[27];
+    let __v_37: G = __r_arr[28];
+    let __v_38: G = __r_arr[29];
+    let __v_39: G = __r_arr[30];
+    let __v_40: G = __r_arr[31];
+    let __v_41: G = __r_arr[32];
+    let __v_42: G = __r_arr[33];
+    let __v_43: G = __r_arr[34];
+    let __v_44: G = __r_arr[35];
+    let __v_45: G = __r_arr[36];
+    let __v_46: G = __r_arr[37];
+    let __v_47: G = __r_arr[38];
+    let __v_48: G = __r_arr[39];
+    let __v_49: G = __r_arr[40];
+    let __v_50: G = __r_arr[41];
+    let __v_51: G = __r_arr[42];
+    let __v_52: G = __r_arr[43];
+    let __v_53: G = __r_arr[44];
+    let __v_54: G = __r_arr[45];
+    let __v_55: G = __r_arr[46];
+    let __v_56: G = __r_arr[47];
+    let __v_57: G = __r_arr[48];
+    let __v_58: G = __r_arr[49];
+    let __v_59: G = __r_arr[50];
+    let __v_60: G = __r_arr[51];
+    let __v_61: G = __r_arr[52];
+    let __v_62: G = __r_arr[53];
+    let __v_63: G = __r_arr[54];
+    let __v_64: G = __r_arr[55];
+    let __v_65: G = __r_arr[56];
+    let __v_66: G = __r_arr[57];
+    let __v_67: G = __r_arr[58];
+    let __v_68: G = __r_arr[59];
+    let __v_69: G = __r_arr[60];
+    let __v_70: G = __r_arr[61];
+    let __v_71: G = __r_arr[62];
+    let __v_72: G = __r_arr[63];
+    match __v_2.as_canonical_u64() {
+      1023u64 => {
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_73: G = __r_arr[0];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_74: G = __loaded[0];
+        let __v_75: G = __loaded[1];
+        let __v_76: G = __loaded[2];
+        let __v_77: G = __loaded[3];
+        let __v_78: G = __loaded[4];
+        let __v_79: G = __loaded[5];
+        let __v_80: G = __loaded[6];
+        let __v_81: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_82: G = __r_arr[0];
+        let __v_83: G = (__v_73 * __v_82);
+        let __v_84: G = (__v_8 * __v_83);
+        let __v_85: G = (__v_84 + __v_7);
+        let __v_86: G = G::from_u64(103);
+        let __v_87: G = G::from_u64(230);
+        let __v_88: G = G::from_u64(9);
+        let __v_89: G = G::from_u64(106);
+        let __v_90: G = G::from_u64(133);
+        let __v_91: G = G::from_u64(174);
+        let __v_92: G = G::from_u64(103);
+        let __v_93: G = G::from_u64(187);
+        let __v_94: G = G::from_u64(114);
+        let __v_95: G = G::from_u64(243);
+        let __v_96: G = G::from_u64(110);
+        let __v_97: G = G::from_u64(60);
+        let __v_98: G = G::from_u64(58);
+        let __v_99: G = G::from_u64(245);
+        let __v_100: G = G::from_u64(79);
+        let __v_101: G = G::from_u64(165);
+        let __v_102: G = G::from_u64(127);
+        let __v_103: G = G::from_u64(82);
+        let __v_104: G = G::from_u64(14);
+        let __v_105: G = G::from_u64(81);
+        let __v_106: G = G::from_u64(140);
+        let __v_107: G = G::from_u64(104);
+        let __v_108: G = G::from_u64(5);
+        let __v_109: G = G::from_u64(155);
+        let __v_110: G = G::from_u64(171);
+        let __v_111: G = G::from_u64(217);
+        let __v_112: G = G::from_u64(131);
+        let __v_113: G = G::from_u64(31);
+        let __v_114: G = G::from_u64(25);
+        let __v_115: G = G::from_u64(205);
+        let __v_116: G = G::from_u64(224);
+        let __v_117: G = G::from_u64(91);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_118: G = __loaded[0];
+        let __v_119: G = __loaded[1];
+        let __v_120: G = __loaded[2];
+        let __v_121: G = __loaded[3];
+        let __v_122: G = __loaded[4];
+        let __v_123: G = __loaded[5];
+        let __v_124: G = __loaded[6];
+        let __v_125: G = __loaded[7];
+        let __v_126: G = __loaded[8];
+        let __v_127: G = __loaded[9];
+        let __v_128: G = __loaded[10];
+        let __v_129: G = __loaded[11];
+        let __v_130: G = __loaded[12];
+        let __v_131: G = __loaded[13];
+        let __v_132: G = __loaded[14];
+        let __v_133: G = __loaded[15];
+        let __v_134: G = __loaded[16];
+        let __v_135: G = __loaded[17];
+        let __v_136: G = __loaded[18];
+        let __v_137: G = __loaded[19];
+        let __v_138: G = __loaded[20];
+        let __v_139: G = __loaded[21];
+        let __v_140: G = __loaded[22];
+        let __v_141: G = __loaded[23];
+        let __v_142: G = __loaded[24];
+        let __v_143: G = __loaded[25];
+        let __v_144: G = __loaded[26];
+        let __v_145: G = __loaded[27];
+        let __v_146: G = __loaded[28];
+        let __v_147: G = __loaded[29];
+        let __v_148: G = __loaded[30];
+        let __v_149: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_150: G = __loaded[0];
+        let __v_151: G = __loaded[1];
+        let __v_152: G = __loaded[2];
+        let __v_153: G = __loaded[3];
+        let __v_154: G = __loaded[4];
+        let __v_155: G = __loaded[5];
+        let __v_156: G = __loaded[6];
+        let __v_157: G = __loaded[7];
+        let __v_158: G = G::from_u64(64);
+        let __v_159: G = G::from_u64(103);
+        let __v_160: G = G::from_u64(230);
+        let __v_161: G = G::from_u64(9);
+        let __v_162: G = G::from_u64(106);
+        let __v_163: G = G::from_u64(133);
+        let __v_164: G = G::from_u64(174);
+        let __v_165: G = G::from_u64(103);
+        let __v_166: G = G::from_u64(187);
+        let __v_167: G = G::from_u64(114);
+        let __v_168: G = G::from_u64(243);
+        let __v_169: G = G::from_u64(110);
+        let __v_170: G = G::from_u64(60);
+        let __v_171: G = G::from_u64(58);
+        let __v_172: G = G::from_u64(245);
+        let __v_173: G = G::from_u64(79);
+        let __v_174: G = G::from_u64(165);
+        let __v_175: G = G::from_u64(0);
+        let __v_176: G = G::from_u64(0);
+        let __v_177: G = G::from_u64(0);
+        let __v_178: G = G::from_u64(0);
+        let __v_179: G = G::from_u64(0);
+        let __v_180: G = G::from_u64(0);
+        let __v_181: G = G::from_u64(0);
+        let __v_182: G = G::from_u64(0);
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __v_183: G = __r_arr[0];
+        let __v_184: G = __r_arr[1];
+        let __v_185: G = __r_arr[2];
+        let __v_186: G = __r_arr[3];
+        let __v_187: G = __r_arr[4];
+        let __v_188: G = __r_arr[5];
+        let __v_189: G = __r_arr[6];
+        let __v_190: G = __r_arr[7];
+        let __v_191: G = __r_arr[8];
+        let __v_192: G = __r_arr[9];
+        let __v_193: G = __r_arr[10];
+        let __v_194: G = __r_arr[11];
+        let __v_195: G = __r_arr[12];
+        let __v_196: G = __r_arr[13];
+        let __v_197: G = __r_arr[14];
+        let __v_198: G = __r_arr[15];
+        let __v_199: G = __r_arr[16];
+        let __v_200: G = __r_arr[17];
+        let __v_201: G = __r_arr[18];
+        let __v_202: G = __r_arr[19];
+        let __v_203: G = __r_arr[20];
+        let __v_204: G = __r_arr[21];
+        let __v_205: G = __r_arr[22];
+        let __v_206: G = __r_arr[23];
+        let __v_207: G = __r_arr[24];
+        let __v_208: G = __r_arr[25];
+        let __v_209: G = __r_arr[26];
+        let __v_210: G = __r_arr[27];
+        let __v_211: G = __r_arr[28];
+        let __v_212: G = __r_arr[29];
+        let __v_213: G = __r_arr[30];
+        let __v_214: G = __r_arr[31];
+        let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_216: G = G::from_u64(1);
+        let __v_217: G = G::from_u64(1);
+        let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_219: G = G::from_u64(0);
+        let __v_220: G = G::from_u64(0);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_221: G = __loaded[0];
+        let __v_222: G = __loaded[1];
+        let __v_223: G = __loaded[2];
+        let __v_224: G = __loaded[3];
+        let __v_225: G = __loaded[4];
+        let __v_226: G = __loaded[5];
+        let __v_227: G = __loaded[6];
+        let __v_228: G = __loaded[7];
+        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+        let __v_229: G = __r_arr[0];
+        let __v_230: G = __r_arr[1];
+        let __v_231: G = __r_arr[2];
+        let __v_232: G = __r_arr[3];
+        let __v_233: G = __r_arr[4];
+        let __v_234: G = __r_arr[5];
+        let __v_235: G = __r_arr[6];
+        let __v_236: G = __r_arr[7];
+        let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+        let __v_239: G = __r_arr[0];
+        let __ret: [G; OUT_79] = [__v_239];
+        if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_73: G = __r_arr[0];
+        let __v_74: G = (__v_73 * __v_7);
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_75: G = __r_arr[0];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_76: G = __loaded[0];
+        let __v_77: G = __loaded[1];
+        let __v_78: G = __loaded[2];
+        let __v_79: G = __loaded[3];
+        let __v_80: G = __loaded[4];
+        let __v_81: G = __loaded[5];
+        let __v_82: G = __loaded[6];
+        let __v_83: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_84: G = __r_arr[0];
+        let __v_85: G = (__v_84 * __v_8);
+        let __v_86: G = (__v_75 * __v_85);
+        let __v_87: G = G::from_u64(63);
+        let __v_88: G = (__v_2 - __v_87);
+        let __v_89: G = G::from_bool((__v_88 == G::ZERO));
+        let __v_90: G = (__v_89 * __v_6);
+        let __v_91: G = (__v_86 + __v_90);
+        let __v_92: G = (__v_74 + __v_91);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_93: G = __loaded[0];
+        let __v_94: G = __loaded[1];
+        let __v_95: G = __loaded[2];
+        let __v_96: G = __loaded[3];
+        let __v_97: G = __loaded[4];
+        let __v_98: G = __loaded[5];
+        let __v_99: G = __loaded[6];
+        let __v_100: G = __loaded[7];
+        let __v_101: G = __loaded[8];
+        let __v_102: G = __loaded[9];
+        let __v_103: G = __loaded[10];
+        let __v_104: G = __loaded[11];
+        let __v_105: G = __loaded[12];
+        let __v_106: G = __loaded[13];
+        let __v_107: G = __loaded[14];
+        let __v_108: G = __loaded[15];
+        let __v_109: G = __loaded[16];
+        let __v_110: G = __loaded[17];
+        let __v_111: G = __loaded[18];
+        let __v_112: G = __loaded[19];
+        let __v_113: G = __loaded[20];
+        let __v_114: G = __loaded[21];
+        let __v_115: G = __loaded[22];
+        let __v_116: G = __loaded[23];
+        let __v_117: G = __loaded[24];
+        let __v_118: G = __loaded[25];
+        let __v_119: G = __loaded[26];
+        let __v_120: G = __loaded[27];
+        let __v_121: G = __loaded[28];
+        let __v_122: G = __loaded[29];
+        let __v_123: G = __loaded[30];
+        let __v_124: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_125: G = __loaded[0];
+        let __v_126: G = __loaded[1];
+        let __v_127: G = __loaded[2];
+        let __v_128: G = __loaded[3];
+        let __v_129: G = __loaded[4];
+        let __v_130: G = __loaded[5];
+        let __v_131: G = __loaded[6];
+        let __v_132: G = __loaded[7];
+        let __v_133: G = G::from_u64(64);
+        let __v_134: G = G::from_u64(103);
+        let __v_135: G = G::from_u64(230);
+        let __v_136: G = G::from_u64(9);
+        let __v_137: G = G::from_u64(106);
+        let __v_138: G = G::from_u64(133);
+        let __v_139: G = G::from_u64(174);
+        let __v_140: G = G::from_u64(103);
+        let __v_141: G = G::from_u64(187);
+        let __v_142: G = G::from_u64(114);
+        let __v_143: G = G::from_u64(243);
+        let __v_144: G = G::from_u64(110);
+        let __v_145: G = G::from_u64(60);
+        let __v_146: G = G::from_u64(58);
+        let __v_147: G = G::from_u64(245);
+        let __v_148: G = G::from_u64(79);
+        let __v_149: G = G::from_u64(165);
+        let __v_150: G = G::from_u64(0);
+        let __v_151: G = G::from_u64(0);
+        let __v_152: G = G::from_u64(0);
+        let __v_153: G = G::from_u64(0);
+        let __v_154: G = G::from_u64(0);
+        let __v_155: G = G::from_u64(0);
+        let __v_156: G = G::from_u64(0);
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __v_157: G = __r_arr[0];
+        let __v_158: G = __r_arr[1];
+        let __v_159: G = __r_arr[2];
+        let __v_160: G = __r_arr[3];
+        let __v_161: G = __r_arr[4];
+        let __v_162: G = __r_arr[5];
+        let __v_163: G = __r_arr[6];
+        let __v_164: G = __r_arr[7];
+        let __v_165: G = __r_arr[8];
+        let __v_166: G = __r_arr[9];
+        let __v_167: G = __r_arr[10];
+        let __v_168: G = __r_arr[11];
+        let __v_169: G = __r_arr[12];
+        let __v_170: G = __r_arr[13];
+        let __v_171: G = __r_arr[14];
+        let __v_172: G = __r_arr[15];
+        let __v_173: G = __r_arr[16];
+        let __v_174: G = __r_arr[17];
+        let __v_175: G = __r_arr[18];
+        let __v_176: G = __r_arr[19];
+        let __v_177: G = __r_arr[20];
+        let __v_178: G = __r_arr[21];
+        let __v_179: G = __r_arr[22];
+        let __v_180: G = __r_arr[23];
+        let __v_181: G = __r_arr[24];
+        let __v_182: G = __r_arr[25];
+        let __v_183: G = __r_arr[26];
+        let __v_184: G = __r_arr[27];
+        let __v_185: G = __r_arr[28];
+        let __v_186: G = __r_arr[29];
+        let __v_187: G = __r_arr[30];
+        let __v_188: G = __r_arr[31];
+        let __v_189: G = G::from_u64(1);
+        let __v_190: G = G::from_u64(1);
+        let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_192: G = G::from_u64(0);
+        let __v_193: G = G::from_u64(1);
+        let __v_194: G = (__v_2 + __v_193);
+        let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+        let __v_196: G = __r_arr[0];
+        let __ret: [G; OUT_79] = [__v_196];
+        if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
     }
-  })
-}
-
-const INPUT_SIZE_141: usize = 25;
-const IN_141: usize = 25;
-const OUT_141: usize = 1;
-fn aiur_fn_141(
-  inp: [G; IN_141],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_141], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    match __v_1.as_canonical_u64() {
-      _ => {
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(0);
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
-        match __v_29.as_canonical_u64() {
-          _ => {
-            let __v_31: G = G::from_u64(0);
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_25, __v_0, __v_20, __v_19, __v_31, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = G::from_u64(1);
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __v_35: G = __r_arr[1];
-            match __v_34.as_canonical_u64() {
-              _ => {
-                let __v_36: G = G::from_u64(0);
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_32, __v_0, __v_20, __v_19, __v_36, __v_18, __v_15, __v_16, __v_17, __v_34, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-                let __v_37: G = __r_arr[0];
-                let __v_38: G = G::from_u64(2);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                let __v_39: G = __r_arr[0];
-                let __v_40: G = __r_arr[1];
-                match __v_39.as_canonical_u64() {
-                  _ => {
-                    let __v_41: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_37, __v_0, __v_20, __v_19, __v_41, __v_18, __v_15, __v_16, __v_17, __v_39, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
-                    let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_42, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
-                    let __v_43: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_43, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
-                    let __v_44: G = __r_arr[0];
-                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_43.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-                    let __v_45: G = __loaded[0];
-                    let __v_46: G = __loaded[1];
-                    let __v_47: G = __loaded[2];
-                    let __v_48: G = __loaded[3];
-                    let __v_49: G = __loaded[4];
-                    let __v_50: G = __loaded[5];
-                    let __v_51: G = __loaded[6];
-                    match __v_45.as_canonical_u64() {
-                      0u64 => {
-                        match __v_46.as_canonical_u64() {
-                          _ => {
-                            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_49, __v_50, __v_21, __v_22, __v_2, __v_0, __v_20, __v_51, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
-                            let __v_52: G = __r_arr[0];
-                            let __v_53: G = __r_arr[1];
-                            let __v_54: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_23, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                            let __v_55: G = __r_arr[0];
-                            let __v_56: G = __r_arr[1];
-                            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
-                            let __v_57: G = __r_arr[0];
-                            let __v_58: G = (__v_57 - __v_24);
-                            let __v_59: G = G::from_bool((__v_58 == G::ZERO));
-                            let __v_60: G = G::from_u64(1);
-                            if (__v_59 != __v_60) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                            let __v_61: G = __r_arr[0];
-                            let __v_62: G = G::from_u64(3);
-                            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
-                            let __v_63: G = __r_arr[0];
-                            let __v_64: G = (__v_62 + __v_63);
-                            let __v_65: G = (__v_61 - __v_64);
-                            let __v_66: G = G::from_bool((__v_65 == G::ZERO));
-                            let __v_67: G = G::from_u64(1);
-                            if (__v_66 != __v_67) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                            let __v_68: G = __r_arr[0];
-                            let __v_69: G = (__v_68 - __v_18);
-                            let __v_70: G = G::from_bool((__v_69 == G::ZERO));
-                            let __v_71: G = G::from_u64(1);
-                            if (__v_70 != __v_71) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-                            let __v_72: G = __r_arr[0];
-                            let __v_73: G = G::from_u64(1);
-                            if (__v_72 != __v_73) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                            let __v_74: G = __r_arr[0];
-                            let __v_75: G = (__v_74 - __v_18);
-                            let __v_76: G = G::from_bool((__v_75 == G::ZERO));
-                            let __v_77: G = G::from_u64(1);
-                            if (__v_76 != __v_77) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_11, __v_34, __v_27, __v_0, __v_35, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-                            let __v_78: G = __r_arr[0];
-                            let __v_79: G = G::from_u64(1);
-                            if (__v_78 != __v_79) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_79.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                            let __v_80: G = __r_arr[0];
-                            let __v_81: G = (__v_80 - __v_18);
-                            let __v_82: G = G::from_bool((__v_81 == G::ZERO));
-                            let __v_83: G = G::from_u64(1);
-                            if (__v_82 != __v_83) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_83.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-                            let __v_84: G = __r_arr[0];
-                            let __v_85: G = G::from_u64(1);
-                            if (__v_84 != __v_85) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_85.as_canonical_u64(), msg: None });
-                            }
-                            let __v_86: G = (__v_46 - __v_20);
-                            let __v_87: G = G::from_bool((__v_86 == G::ZERO));
-                            let __v_88: G = G::from_u64(1);
-                            if (__v_87 != __v_88) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
-                            }
-                            let __v_89: G = (__v_55 - __v_52);
-                            let __v_90: G = G::from_bool((__v_89 == G::ZERO));
-                            let __v_91: G = (__v_56 - __v_53);
-                            let __v_92: G = G::from_bool((__v_91 == G::ZERO));
-                            let __v_93: G = (__v_90 * __v_92);
-                            let __v_94: G = G::from_u64(1);
-                            if (__v_93 != __v_94) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: None });
-                            }
-                            let __v_95: G = G::from_u64(1);
-                            let __ret: [G; OUT_141] = [__v_95];
-                            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
-                      },
-                    }
-                  },
-                }
-              },
-            }
-          },
-        }
-      },
+  })
+}
+
+const INPUT_SIZE_80: usize = 24;
+const IN_80: usize = 24;
+const OUT_80: usize = 16;
+fn aiur_fn_80(
+  inp: [G; IN_80],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_80], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_24: G = G::from_u8(__u32_bytes[0]);
+    let __v_25: G = G::from_u8(__u32_bytes[1]);
+    let __v_26: G = G::from_u8(__u32_bytes[2]);
+    let __v_27: G = G::from_u8(__u32_bytes[3]);
+    let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = (__v_28 - __v_29);
+    let __v_31: G = G::from_u64(2);
+    let __v_32: G = (__v_28 - __v_31);
+    let __v_33: G = (__v_30 * __v_32);
+    let __v_34: G = (__v_28 * __v_33);
+    let __v_35: G = G::from_u64(0);
+    if (__v_34 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_36: G = if unconstrained { Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record) };
+    let __v_37: G = if unconstrained { Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record) };
+    let __v_38: G = if unconstrained { Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record) };
+    let __v_39: G = if unconstrained { Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record) };
+    let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8) | (__v_36.as_canonical_u64() << 16) | (__v_37.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_40: G = G::from_u8(__u32_bytes[0]);
+    let __v_41: G = G::from_u8(__u32_bytes[1]);
+    let __v_42: G = G::from_u8(__u32_bytes[2]);
+    let __v_43: G = G::from_u8(__u32_bytes[3]);
+    let __v_44: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_45: G = (__v_44 * __v_44);
+    if (__v_45 != __v_44) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record) };
+    let __v_46: G = __b2_out.0;
+    let __v_47: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record) };
+    let __v_48: G = __b2_out.0;
+    let __v_49: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record) };
+    let __v_50: G = __b2_out.0;
+    let __v_51: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record) };
+    let __v_52: G = __b2_out.0;
+    let __v_53: G = __b2_out.1;
+    let __v_54: G = (__v_48 + __v_51);
+    let __v_55: G = (__v_50 + __v_53);
+    let __v_56: G = (__v_52 + __v_47);
+    let __v_57: G = (__v_46 + __v_49);
+    let __u32_sum: u128 = u128::from(((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8) | (__v_26.as_canonical_u64() << 16) | (__v_27.as_canonical_u64() << 24))) + u128::from(((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8) | (__v_56.as_canonical_u64() << 16) | (__v_57.as_canonical_u64() << 24))) + u128::from(((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8) | (__v_22.as_canonical_u64() << 16) | (__v_23.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_58: G = G::from_u8(__u32_bytes[0]);
+    let __v_59: G = G::from_u8(__u32_bytes[1]);
+    let __v_60: G = G::from_u8(__u32_bytes[2]);
+    let __v_61: G = G::from_u8(__u32_bytes[3]);
+    let __v_62: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_63: G = G::from_u64(1);
+    let __v_64: G = (__v_62 - __v_63);
+    let __v_65: G = G::from_u64(2);
+    let __v_66: G = (__v_62 - __v_65);
+    let __v_67: G = (__v_64 * __v_66);
+    let __v_68: G = (__v_62 * __v_67);
+    let __v_69: G = G::from_u64(0);
+    if (__v_68 != __v_69) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_70: G = if unconstrained { Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record) };
+    let __v_71: G = if unconstrained { Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record) };
+    let __v_72: G = if unconstrained { Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record) };
+    let __v_73: G = if unconstrained { Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record) };
+    let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_71.as_canonical_u64() << 0) | (__v_72.as_canonical_u64() << 8) | (__v_73.as_canonical_u64() << 16) | (__v_70.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_74: G = G::from_u8(__u32_bytes[0]);
+    let __v_75: G = G::from_u8(__u32_bytes[1]);
+    let __v_76: G = G::from_u8(__u32_bytes[2]);
+    let __v_77: G = G::from_u8(__u32_bytes[3]);
+    let __v_78: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_74; let __vj = __v_75; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_79: G = (__v_78 * __v_78);
+    if (__v_79 != __v_78) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record) };
+    let __v_80: G = __b2_out.0;
+    let __v_81: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record) };
+    let __v_82: G = __b2_out.0;
+    let __v_83: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record) };
+    let __v_84: G = __b2_out.0;
+    let __v_85: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record) };
+    let __v_86: G = __b2_out.0;
+    let __v_87: G = __b2_out.1;
+    let __v_88: G = (__v_80 + __v_83);
+    let __v_89: G = (__v_82 + __v_85);
+    let __v_90: G = (__v_84 + __v_87);
+    let __v_91: G = (__v_86 + __v_81);
+    let __ret: [G; OUT_80] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
+    if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_81: usize = 128;
+const IN_81: usize = 128;
+const OUT_81: usize = 128;
+fn aiur_fn_81(
+  inp: [G; IN_81],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_81], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = inp[57];
+    let __v_58: G = inp[58];
+    let __v_59: G = inp[59];
+    let __v_60: G = inp[60];
+    let __v_61: G = inp[61];
+    let __v_62: G = inp[62];
+    let __v_63: G = inp[63];
+    let __v_64: G = inp[64];
+    let __v_65: G = inp[65];
+    let __v_66: G = inp[66];
+    let __v_67: G = inp[67];
+    let __v_68: G = inp[68];
+    let __v_69: G = inp[69];
+    let __v_70: G = inp[70];
+    let __v_71: G = inp[71];
+    let __v_72: G = inp[72];
+    let __v_73: G = inp[73];
+    let __v_74: G = inp[74];
+    let __v_75: G = inp[75];
+    let __v_76: G = inp[76];
+    let __v_77: G = inp[77];
+    let __v_78: G = inp[78];
+    let __v_79: G = inp[79];
+    let __v_80: G = inp[80];
+    let __v_81: G = inp[81];
+    let __v_82: G = inp[82];
+    let __v_83: G = inp[83];
+    let __v_84: G = inp[84];
+    let __v_85: G = inp[85];
+    let __v_86: G = inp[86];
+    let __v_87: G = inp[87];
+    let __v_88: G = inp[88];
+    let __v_89: G = inp[89];
+    let __v_90: G = inp[90];
+    let __v_91: G = inp[91];
+    let __v_92: G = inp[92];
+    let __v_93: G = inp[93];
+    let __v_94: G = inp[94];
+    let __v_95: G = inp[95];
+    let __v_96: G = inp[96];
+    let __v_97: G = inp[97];
+    let __v_98: G = inp[98];
+    let __v_99: G = inp[99];
+    let __v_100: G = inp[100];
+    let __v_101: G = inp[101];
+    let __v_102: G = inp[102];
+    let __v_103: G = inp[103];
+    let __v_104: G = inp[104];
+    let __v_105: G = inp[105];
+    let __v_106: G = inp[106];
+    let __v_107: G = inp[107];
+    let __v_108: G = inp[108];
+    let __v_109: G = inp[109];
+    let __v_110: G = inp[110];
+    let __v_111: G = inp[111];
+    let __v_112: G = inp[112];
+    let __v_113: G = inp[113];
+    let __v_114: G = inp[114];
+    let __v_115: G = inp[115];
+    let __v_116: G = inp[116];
+    let __v_117: G = inp[117];
+    let __v_118: G = inp[118];
+    let __v_119: G = inp[119];
+    let __v_120: G = inp[120];
+    let __v_121: G = inp[121];
+    let __v_122: G = inp[122];
+    let __v_123: G = inp[123];
+    let __v_124: G = inp[124];
+    let __v_125: G = inp[125];
+    let __v_126: G = inp[126];
+    let __v_127: G = inp[127];
+    let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))) + u128::from(((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8) | (__v_66.as_canonical_u64() << 16) | (__v_67.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_128: G = G::from_u8(__u32_bytes[0]);
+    let __v_129: G = G::from_u8(__u32_bytes[1]);
+    let __v_130: G = G::from_u8(__u32_bytes[2]);
+    let __v_131: G = G::from_u8(__u32_bytes[3]);
+    let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_133: G = G::from_u64(1);
+    let __v_134: G = (__v_132 - __v_133);
+    let __v_135: G = G::from_u64(2);
+    let __v_136: G = (__v_132 - __v_135);
+    let __v_137: G = (__v_134 * __v_136);
+    let __v_138: G = (__v_132 * __v_137);
+    let __v_139: G = G::from_u64(0);
+    if (__v_138 != __v_139) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_140: G = if unconstrained { Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record) };
+    let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) };
+    let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) };
+    let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) };
+    let __u32_sum: u128 = u128::from(((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8) | (__v_34.as_canonical_u64() << 16) | (__v_35.as_canonical_u64() << 24))) + u128::from(((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8) | (__v_140.as_canonical_u64() << 16) | (__v_141.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_144: G = G::from_u8(__u32_bytes[0]);
+    let __v_145: G = G::from_u8(__u32_bytes[1]);
+    let __v_146: G = G::from_u8(__u32_bytes[2]);
+    let __v_147: G = G::from_u8(__u32_bytes[3]);
+    let __v_148: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_149: G = (__v_148 * __v_148);
+    if (__v_149 != __v_148) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record) };
+    let __v_150: G = __b2_out.0;
+    let __v_151: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) };
+    let __v_152: G = __b2_out.0;
+    let __v_153: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) };
+    let __v_154: G = __b2_out.0;
+    let __v_155: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) };
+    let __v_156: G = __b2_out.0;
+    let __v_157: G = __b2_out.1;
+    let __v_158: G = (__v_152 + __v_155);
+    let __v_159: G = (__v_154 + __v_157);
+    let __v_160: G = (__v_156 + __v_151);
+    let __v_161: G = (__v_150 + __v_153);
+    let __u32_sum: u128 = u128::from(((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8) | (__v_130.as_canonical_u64() << 16) | (__v_131.as_canonical_u64() << 24))) + u128::from(((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8) | (__v_160.as_canonical_u64() << 16) | (__v_161.as_canonical_u64() << 24))) + u128::from(((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8) | (__v_70.as_canonical_u64() << 16) | (__v_71.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_162: G = G::from_u8(__u32_bytes[0]);
+    let __v_163: G = G::from_u8(__u32_bytes[1]);
+    let __v_164: G = G::from_u8(__u32_bytes[2]);
+    let __v_165: G = G::from_u8(__u32_bytes[3]);
+    let __v_166: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_167: G = G::from_u64(1);
+    let __v_168: G = (__v_166 - __v_167);
+    let __v_169: G = G::from_u64(2);
+    let __v_170: G = (__v_166 - __v_169);
+    let __v_171: G = (__v_168 * __v_170);
+    let __v_172: G = (__v_166 * __v_171);
+    let __v_173: G = G::from_u64(0);
+    if (__v_172 != __v_173) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_174: G = if unconstrained { Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record) };
+    let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) };
+    let __v_176: G = if unconstrained { Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record) };
+    let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) };
+    let __u32_sum: u128 = u128::from(((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8) | (__v_146.as_canonical_u64() << 16) | (__v_147.as_canonical_u64() << 24))) + u128::from(((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8) | (__v_177.as_canonical_u64() << 16) | (__v_174.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_178: G = G::from_u8(__u32_bytes[0]);
+    let __v_179: G = G::from_u8(__u32_bytes[1]);
+    let __v_180: G = G::from_u8(__u32_bytes[2]);
+    let __v_181: G = G::from_u8(__u32_bytes[3]);
+    let __v_182: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_180; let __vj = __v_181; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_183: G = (__v_182 * __v_182);
+    if (__v_183 != __v_182) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record) };
+    let __v_184: G = __b2_out.0;
+    let __v_185: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) };
+    let __v_186: G = __b2_out.0;
+    let __v_187: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) };
+    let __v_188: G = __b2_out.0;
+    let __v_189: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) };
+    let __v_190: G = __b2_out.0;
+    let __v_191: G = __b2_out.1;
+    let __v_192: G = (__v_184 + __v_187);
+    let __v_193: G = (__v_186 + __v_189);
+    let __v_194: G = (__v_188 + __v_191);
+    let __v_195: G = (__v_190 + __v_185);
+    let __u32_sum: u128 = u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8) | (__v_22.as_canonical_u64() << 16) | (__v_23.as_canonical_u64() << 24))) + u128::from(((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8) | (__v_74.as_canonical_u64() << 16) | (__v_75.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_196: G = G::from_u8(__u32_bytes[0]);
+    let __v_197: G = G::from_u8(__u32_bytes[1]);
+    let __v_198: G = G::from_u8(__u32_bytes[2]);
+    let __v_199: G = G::from_u8(__u32_bytes[3]);
+    let __v_200: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_201: G = G::from_u64(1);
+    let __v_202: G = (__v_200 - __v_201);
+    let __v_203: G = G::from_u64(2);
+    let __v_204: G = (__v_200 - __v_203);
+    let __v_205: G = (__v_202 * __v_204);
+    let __v_206: G = (__v_200 * __v_205);
+    let __v_207: G = G::from_u64(0);
+    if (__v_206 != __v_207) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_207.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_208: G = if unconstrained { Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record) };
+    let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) };
+    let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) };
+    let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) };
+    let __u32_sum: u128 = u128::from(((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8) | (__v_38.as_canonical_u64() << 16) | (__v_39.as_canonical_u64() << 24))) + u128::from(((__v_210.as_canonical_u64() << 0) | (__v_211.as_canonical_u64() << 8) | (__v_208.as_canonical_u64() << 16) | (__v_209.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_212: G = G::from_u8(__u32_bytes[0]);
+    let __v_213: G = G::from_u8(__u32_bytes[1]);
+    let __v_214: G = G::from_u8(__u32_bytes[2]);
+    let __v_215: G = G::from_u8(__u32_bytes[3]);
+    let __v_216: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_212; let __vj = __v_213; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_214; let __vj = __v_215; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_217: G = (__v_216 * __v_216);
+    if (__v_217 != __v_216) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_216.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record) };
+    let __v_218: G = __b2_out.0;
+    let __v_219: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) };
+    let __v_220: G = __b2_out.0;
+    let __v_221: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) };
+    let __v_222: G = __b2_out.0;
+    let __v_223: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) };
+    let __v_224: G = __b2_out.0;
+    let __v_225: G = __b2_out.1;
+    let __v_226: G = (__v_220 + __v_223);
+    let __v_227: G = (__v_222 + __v_225);
+    let __v_228: G = (__v_224 + __v_219);
+    let __v_229: G = (__v_218 + __v_221);
+    let __u32_sum: u128 = u128::from(((__v_196.as_canonical_u64() << 0) | (__v_197.as_canonical_u64() << 8) | (__v_198.as_canonical_u64() << 16) | (__v_199.as_canonical_u64() << 24))) + u128::from(((__v_226.as_canonical_u64() << 0) | (__v_227.as_canonical_u64() << 8) | (__v_228.as_canonical_u64() << 16) | (__v_229.as_canonical_u64() << 24))) + u128::from(((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8) | (__v_78.as_canonical_u64() << 16) | (__v_79.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_230: G = G::from_u8(__u32_bytes[0]);
+    let __v_231: G = G::from_u8(__u32_bytes[1]);
+    let __v_232: G = G::from_u8(__u32_bytes[2]);
+    let __v_233: G = G::from_u8(__u32_bytes[3]);
+    let __v_234: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_230; let __vj = __v_231; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_232; let __vj = __v_233; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_235: G = G::from_u64(1);
+    let __v_236: G = (__v_234 - __v_235);
+    let __v_237: G = G::from_u64(2);
+    let __v_238: G = (__v_234 - __v_237);
+    let __v_239: G = (__v_236 * __v_238);
+    let __v_240: G = (__v_234 * __v_239);
+    let __v_241: G = G::from_u64(0);
+    if (__v_240 != __v_241) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_242: G = if unconstrained { Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record) };
+    let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) };
+    let __v_244: G = if unconstrained { Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record) };
+    let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) };
+    let __u32_sum: u128 = u128::from(((__v_212.as_canonical_u64() << 0) | (__v_213.as_canonical_u64() << 8) | (__v_214.as_canonical_u64() << 16) | (__v_215.as_canonical_u64() << 24))) + u128::from(((__v_243.as_canonical_u64() << 0) | (__v_244.as_canonical_u64() << 8) | (__v_245.as_canonical_u64() << 16) | (__v_242.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_246: G = G::from_u8(__u32_bytes[0]);
+    let __v_247: G = G::from_u8(__u32_bytes[1]);
+    let __v_248: G = G::from_u8(__u32_bytes[2]);
+    let __v_249: G = G::from_u8(__u32_bytes[3]);
+    let __v_250: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_246; let __vj = __v_247; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_248; let __vj = __v_249; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_251: G = (__v_250 * __v_250);
+    if (__v_251 != __v_250) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_250.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record) };
+    let __v_252: G = __b2_out.0;
+    let __v_253: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) };
+    let __v_254: G = __b2_out.0;
+    let __v_255: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) };
+    let __v_256: G = __b2_out.0;
+    let __v_257: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) };
+    let __v_258: G = __b2_out.0;
+    let __v_259: G = __b2_out.1;
+    let __v_260: G = (__v_252 + __v_255);
+    let __v_261: G = (__v_254 + __v_257);
+    let __v_262: G = (__v_256 + __v_259);
+    let __v_263: G = (__v_258 + __v_253);
+    let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8) | (__v_26.as_canonical_u64() << 16) | (__v_27.as_canonical_u64() << 24))) + u128::from(((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8) | (__v_82.as_canonical_u64() << 16) | (__v_83.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_264: G = G::from_u8(__u32_bytes[0]);
+    let __v_265: G = G::from_u8(__u32_bytes[1]);
+    let __v_266: G = G::from_u8(__u32_bytes[2]);
+    let __v_267: G = G::from_u8(__u32_bytes[3]);
+    let __v_268: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_264; let __vj = __v_265; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_266; let __vj = __v_267; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_269: G = G::from_u64(1);
+    let __v_270: G = (__v_268 - __v_269);
+    let __v_271: G = G::from_u64(2);
+    let __v_272: G = (__v_268 - __v_271);
+    let __v_273: G = (__v_270 * __v_272);
+    let __v_274: G = (__v_268 * __v_273);
+    let __v_275: G = G::from_u64(0);
+    if (__v_274 != __v_275) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_275.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_276: G = if unconstrained { Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record) };
+    let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) };
+    let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) };
+    let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) };
+    let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_278.as_canonical_u64() << 0) | (__v_279.as_canonical_u64() << 8) | (__v_276.as_canonical_u64() << 16) | (__v_277.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_280: G = G::from_u8(__u32_bytes[0]);
+    let __v_281: G = G::from_u8(__u32_bytes[1]);
+    let __v_282: G = G::from_u8(__u32_bytes[2]);
+    let __v_283: G = G::from_u8(__u32_bytes[3]);
+    let __v_284: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_280; let __vj = __v_281; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_282; let __vj = __v_283; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_285: G = (__v_284 * __v_284);
+    if (__v_285 != __v_284) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_284.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record) };
+    let __v_286: G = __b2_out.0;
+    let __v_287: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) };
+    let __v_288: G = __b2_out.0;
+    let __v_289: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) };
+    let __v_290: G = __b2_out.0;
+    let __v_291: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) };
+    let __v_292: G = __b2_out.0;
+    let __v_293: G = __b2_out.1;
+    let __v_294: G = (__v_288 + __v_291);
+    let __v_295: G = (__v_290 + __v_293);
+    let __v_296: G = (__v_292 + __v_287);
+    let __v_297: G = (__v_286 + __v_289);
+    let __u32_sum: u128 = u128::from(((__v_264.as_canonical_u64() << 0) | (__v_265.as_canonical_u64() << 8) | (__v_266.as_canonical_u64() << 16) | (__v_267.as_canonical_u64() << 24))) + u128::from(((__v_294.as_canonical_u64() << 0) | (__v_295.as_canonical_u64() << 8) | (__v_296.as_canonical_u64() << 16) | (__v_297.as_canonical_u64() << 24))) + u128::from(((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8) | (__v_86.as_canonical_u64() << 16) | (__v_87.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_298: G = G::from_u8(__u32_bytes[0]);
+    let __v_299: G = G::from_u8(__u32_bytes[1]);
+    let __v_300: G = G::from_u8(__u32_bytes[2]);
+    let __v_301: G = G::from_u8(__u32_bytes[3]);
+    let __v_302: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_298; let __vj = __v_299; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_303: G = G::from_u64(1);
+    let __v_304: G = (__v_302 - __v_303);
+    let __v_305: G = G::from_u64(2);
+    let __v_306: G = (__v_302 - __v_305);
+    let __v_307: G = (__v_304 * __v_306);
+    let __v_308: G = (__v_302 * __v_307);
+    let __v_309: G = G::from_u64(0);
+    if (__v_308 != __v_309) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_310: G = if unconstrained { Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record) };
+    let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) };
+    let __v_312: G = if unconstrained { Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record) };
+    let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) };
+    let __u32_sum: u128 = u128::from(((__v_280.as_canonical_u64() << 0) | (__v_281.as_canonical_u64() << 8) | (__v_282.as_canonical_u64() << 16) | (__v_283.as_canonical_u64() << 24))) + u128::from(((__v_311.as_canonical_u64() << 0) | (__v_312.as_canonical_u64() << 8) | (__v_313.as_canonical_u64() << 16) | (__v_310.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_314: G = G::from_u8(__u32_bytes[0]);
+    let __v_315: G = G::from_u8(__u32_bytes[1]);
+    let __v_316: G = G::from_u8(__u32_bytes[2]);
+    let __v_317: G = G::from_u8(__u32_bytes[3]);
+    let __v_318: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_314; let __vj = __v_315; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_316; let __vj = __v_317; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_319: G = (__v_318 * __v_318);
+    if (__v_319 != __v_318) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_319.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record) };
+    let __v_320: G = __b2_out.0;
+    let __v_321: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) };
+    let __v_322: G = __b2_out.0;
+    let __v_323: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) };
+    let __v_324: G = __b2_out.0;
+    let __v_325: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) };
+    let __v_326: G = __b2_out.0;
+    let __v_327: G = __b2_out.1;
+    let __v_328: G = (__v_320 + __v_323);
+    let __v_329: G = (__v_322 + __v_325);
+    let __v_330: G = (__v_324 + __v_327);
+    let __v_331: G = (__v_326 + __v_321);
+    let __u32_sum: u128 = u128::from(((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8) | (__v_14.as_canonical_u64() << 16) | (__v_15.as_canonical_u64() << 24))) + u128::from(((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8) | (__v_30.as_canonical_u64() << 16) | (__v_31.as_canonical_u64() << 24))) + u128::from(((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8) | (__v_90.as_canonical_u64() << 16) | (__v_91.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_332: G = G::from_u8(__u32_bytes[0]);
+    let __v_333: G = G::from_u8(__u32_bytes[1]);
+    let __v_334: G = G::from_u8(__u32_bytes[2]);
+    let __v_335: G = G::from_u8(__u32_bytes[3]);
+    let __v_336: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_334; let __vj = __v_335; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_337: G = G::from_u64(1);
+    let __v_338: G = (__v_336 - __v_337);
+    let __v_339: G = G::from_u64(2);
+    let __v_340: G = (__v_336 - __v_339);
+    let __v_341: G = (__v_338 * __v_340);
+    let __v_342: G = (__v_336 * __v_341);
+    let __v_343: G = G::from_u64(0);
+    if (__v_342 != __v_343) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_342.as_canonical_u64(), rhs: __v_343.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_344: G = if unconstrained { Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record) };
+    let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) };
+    let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) };
+    let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) };
+    let __u32_sum: u128 = u128::from(((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8) | (__v_46.as_canonical_u64() << 16) | (__v_47.as_canonical_u64() << 24))) + u128::from(((__v_346.as_canonical_u64() << 0) | (__v_347.as_canonical_u64() << 8) | (__v_344.as_canonical_u64() << 16) | (__v_345.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_348: G = G::from_u8(__u32_bytes[0]);
+    let __v_349: G = G::from_u8(__u32_bytes[1]);
+    let __v_350: G = G::from_u8(__u32_bytes[2]);
+    let __v_351: G = G::from_u8(__u32_bytes[3]);
+    let __v_352: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_353: G = (__v_352 * __v_352);
+    if (__v_353 != __v_352) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_353.as_canonical_u64(), rhs: __v_352.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record) };
+    let __v_354: G = __b2_out.0;
+    let __v_355: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) };
+    let __v_356: G = __b2_out.0;
+    let __v_357: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) };
+    let __v_358: G = __b2_out.0;
+    let __v_359: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) };
+    let __v_360: G = __b2_out.0;
+    let __v_361: G = __b2_out.1;
+    let __v_362: G = (__v_356 + __v_359);
+    let __v_363: G = (__v_358 + __v_361);
+    let __v_364: G = (__v_360 + __v_355);
+    let __v_365: G = (__v_354 + __v_357);
+    let __u32_sum: u128 = u128::from(((__v_332.as_canonical_u64() << 0) | (__v_333.as_canonical_u64() << 8) | (__v_334.as_canonical_u64() << 16) | (__v_335.as_canonical_u64() << 24))) + u128::from(((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8) | (__v_364.as_canonical_u64() << 16) | (__v_365.as_canonical_u64() << 24))) + u128::from(((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8) | (__v_94.as_canonical_u64() << 16) | (__v_95.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_366: G = G::from_u8(__u32_bytes[0]);
+    let __v_367: G = G::from_u8(__u32_bytes[1]);
+    let __v_368: G = G::from_u8(__u32_bytes[2]);
+    let __v_369: G = G::from_u8(__u32_bytes[3]);
+    let __v_370: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_366; let __vj = __v_367; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_368; let __vj = __v_369; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_371: G = G::from_u64(1);
+    let __v_372: G = (__v_370 - __v_371);
+    let __v_373: G = G::from_u64(2);
+    let __v_374: G = (__v_370 - __v_373);
+    let __v_375: G = (__v_372 * __v_374);
+    let __v_376: G = (__v_370 * __v_375);
+    let __v_377: G = G::from_u64(0);
+    if (__v_376 != __v_377) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_377.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_378: G = if unconstrained { Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record) };
+    let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) };
+    let __v_380: G = if unconstrained { Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record) };
+    let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) };
+    let __u32_sum: u128 = u128::from(((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8) | (__v_350.as_canonical_u64() << 16) | (__v_351.as_canonical_u64() << 24))) + u128::from(((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8) | (__v_381.as_canonical_u64() << 16) | (__v_378.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_382: G = G::from_u8(__u32_bytes[0]);
+    let __v_383: G = G::from_u8(__u32_bytes[1]);
+    let __v_384: G = G::from_u8(__u32_bytes[2]);
+    let __v_385: G = G::from_u8(__u32_bytes[3]);
+    let __v_386: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_384; let __vj = __v_385; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_387: G = (__v_386 * __v_386);
+    if (__v_387 != __v_386) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_386.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record) };
+    let __v_388: G = __b2_out.0;
+    let __v_389: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) };
+    let __v_390: G = __b2_out.0;
+    let __v_391: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) };
+    let __v_392: G = __b2_out.0;
+    let __v_393: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) };
+    let __v_394: G = __b2_out.0;
+    let __v_395: G = __b2_out.1;
+    let __v_396: G = (__v_388 + __v_391);
+    let __v_397: G = (__v_390 + __v_393);
+    let __v_398: G = (__v_392 + __v_395);
+    let __v_399: G = (__v_394 + __v_389);
+    let __u32_sum: u128 = u128::from(((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8) | (__v_164.as_canonical_u64() << 16) | (__v_165.as_canonical_u64() << 24))) + u128::from(((__v_260.as_canonical_u64() << 0) | (__v_261.as_canonical_u64() << 8) | (__v_262.as_canonical_u64() << 16) | (__v_263.as_canonical_u64() << 24))) + u128::from(((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8) | (__v_98.as_canonical_u64() << 16) | (__v_99.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_400: G = G::from_u8(__u32_bytes[0]);
+    let __v_401: G = G::from_u8(__u32_bytes[1]);
+    let __v_402: G = G::from_u8(__u32_bytes[2]);
+    let __v_403: G = G::from_u8(__u32_bytes[3]);
+    let __v_404: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_400; let __vj = __v_401; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_402; let __vj = __v_403; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_405: G = G::from_u64(1);
+    let __v_406: G = (__v_404 - __v_405);
+    let __v_407: G = G::from_u64(2);
+    let __v_408: G = (__v_404 - __v_407);
+    let __v_409: G = (__v_406 * __v_408);
+    let __v_410: G = (__v_404 * __v_409);
+    let __v_411: G = G::from_u64(0);
+    if (__v_410 != __v_411) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_410.as_canonical_u64(), rhs: __v_411.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_412: G = if unconstrained { Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record) };
+    let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) };
+    let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) };
+    let __v_415: G = if unconstrained { Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record) };
+    let __u32_sum: u128 = u128::from(((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8) | (__v_316.as_canonical_u64() << 16) | (__v_317.as_canonical_u64() << 24))) + u128::from(((__v_414.as_canonical_u64() << 0) | (__v_415.as_canonical_u64() << 8) | (__v_412.as_canonical_u64() << 16) | (__v_413.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_416: G = G::from_u8(__u32_bytes[0]);
+    let __v_417: G = G::from_u8(__u32_bytes[1]);
+    let __v_418: G = G::from_u8(__u32_bytes[2]);
+    let __v_419: G = G::from_u8(__u32_bytes[3]);
+    let __v_420: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_416; let __vj = __v_417; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_418; let __vj = __v_419; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_421: G = (__v_420 * __v_420);
+    if (__v_421 != __v_420) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_420.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record) };
+    let __v_422: G = __b2_out.0;
+    let __v_423: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) };
+    let __v_424: G = __b2_out.0;
+    let __v_425: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) };
+    let __v_426: G = __b2_out.0;
+    let __v_427: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) };
+    let __v_428: G = __b2_out.0;
+    let __v_429: G = __b2_out.1;
+    let __v_430: G = (__v_424 + __v_427);
+    let __v_431: G = (__v_426 + __v_429);
+    let __v_432: G = (__v_428 + __v_423);
+    let __v_433: G = (__v_422 + __v_425);
+    let __u32_sum: u128 = u128::from(((__v_400.as_canonical_u64() << 0) | (__v_401.as_canonical_u64() << 8) | (__v_402.as_canonical_u64() << 16) | (__v_403.as_canonical_u64() << 24))) + u128::from(((__v_430.as_canonical_u64() << 0) | (__v_431.as_canonical_u64() << 8) | (__v_432.as_canonical_u64() << 16) | (__v_433.as_canonical_u64() << 24))) + u128::from(((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8) | (__v_102.as_canonical_u64() << 16) | (__v_103.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_434: G = G::from_u8(__u32_bytes[0]);
+    let __v_435: G = G::from_u8(__u32_bytes[1]);
+    let __v_436: G = G::from_u8(__u32_bytes[2]);
+    let __v_437: G = G::from_u8(__u32_bytes[3]);
+    let __v_438: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_434; let __vj = __v_435; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_436; let __vj = __v_437; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_439: G = G::from_u64(1);
+    let __v_440: G = (__v_438 - __v_439);
+    let __v_441: G = G::from_u64(2);
+    let __v_442: G = (__v_438 - __v_441);
+    let __v_443: G = (__v_440 * __v_442);
+    let __v_444: G = (__v_438 * __v_443);
+    let __v_445: G = G::from_u64(0);
+    if (__v_444 != __v_445) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_445.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_446: G = if unconstrained { Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record) };
+    let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) };
+    let __v_448: G = if unconstrained { Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record) };
+    let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) };
+    let __u32_sum: u128 = u128::from(((__v_416.as_canonical_u64() << 0) | (__v_417.as_canonical_u64() << 8) | (__v_418.as_canonical_u64() << 16) | (__v_419.as_canonical_u64() << 24))) + u128::from(((__v_447.as_canonical_u64() << 0) | (__v_448.as_canonical_u64() << 8) | (__v_449.as_canonical_u64() << 16) | (__v_446.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_450: G = G::from_u8(__u32_bytes[0]);
+    let __v_451: G = G::from_u8(__u32_bytes[1]);
+    let __v_452: G = G::from_u8(__u32_bytes[2]);
+    let __v_453: G = G::from_u8(__u32_bytes[3]);
+    let __v_454: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_450; let __vj = __v_451; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_452; let __vj = __v_453; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_455: G = (__v_454 * __v_454);
+    if (__v_455 != __v_454) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record) };
+    let __v_456: G = __b2_out.0;
+    let __v_457: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) };
+    let __v_458: G = __b2_out.0;
+    let __v_459: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) };
+    let __v_460: G = __b2_out.0;
+    let __v_461: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) };
+    let __v_462: G = __b2_out.0;
+    let __v_463: G = __b2_out.1;
+    let __v_464: G = (__v_456 + __v_459);
+    let __v_465: G = (__v_458 + __v_461);
+    let __v_466: G = (__v_460 + __v_463);
+    let __v_467: G = (__v_462 + __v_457);
+    let __u32_sum: u128 = u128::from(((__v_230.as_canonical_u64() << 0) | (__v_231.as_canonical_u64() << 8) | (__v_232.as_canonical_u64() << 16) | (__v_233.as_canonical_u64() << 24))) + u128::from(((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8) | (__v_330.as_canonical_u64() << 16) | (__v_331.as_canonical_u64() << 24))) + u128::from(((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8) | (__v_106.as_canonical_u64() << 16) | (__v_107.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_468: G = G::from_u8(__u32_bytes[0]);
+    let __v_469: G = G::from_u8(__u32_bytes[1]);
+    let __v_470: G = G::from_u8(__u32_bytes[2]);
+    let __v_471: G = G::from_u8(__u32_bytes[3]);
+    let __v_472: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_468; let __vj = __v_469; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_470; let __vj = __v_471; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_473: G = G::from_u64(1);
+    let __v_474: G = (__v_472 - __v_473);
+    let __v_475: G = G::from_u64(2);
+    let __v_476: G = (__v_472 - __v_475);
+    let __v_477: G = (__v_474 * __v_476);
+    let __v_478: G = (__v_472 * __v_477);
+    let __v_479: G = G::from_u64(0);
+    if (__v_478 != __v_479) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_480: G = if unconstrained { Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record) };
+    let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) };
+    let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) };
+    let __v_483: G = if unconstrained { Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record) };
+    let __u32_sum: u128 = u128::from(((__v_382.as_canonical_u64() << 0) | (__v_383.as_canonical_u64() << 8) | (__v_384.as_canonical_u64() << 16) | (__v_385.as_canonical_u64() << 24))) + u128::from(((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8) | (__v_480.as_canonical_u64() << 16) | (__v_481.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_484: G = G::from_u8(__u32_bytes[0]);
+    let __v_485: G = G::from_u8(__u32_bytes[1]);
+    let __v_486: G = G::from_u8(__u32_bytes[2]);
+    let __v_487: G = G::from_u8(__u32_bytes[3]);
+    let __v_488: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_484; let __vj = __v_485; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_489: G = (__v_488 * __v_488);
+    if (__v_489 != __v_488) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record) };
+    let __v_490: G = __b2_out.0;
+    let __v_491: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) };
+    let __v_492: G = __b2_out.0;
+    let __v_493: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) };
+    let __v_494: G = __b2_out.0;
+    let __v_495: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) };
+    let __v_496: G = __b2_out.0;
+    let __v_497: G = __b2_out.1;
+    let __v_498: G = (__v_492 + __v_495);
+    let __v_499: G = (__v_494 + __v_497);
+    let __v_500: G = (__v_496 + __v_491);
+    let __v_501: G = (__v_490 + __v_493);
+    let __u32_sum: u128 = u128::from(((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8) | (__v_470.as_canonical_u64() << 16) | (__v_471.as_canonical_u64() << 24))) + u128::from(((__v_498.as_canonical_u64() << 0) | (__v_499.as_canonical_u64() << 8) | (__v_500.as_canonical_u64() << 16) | (__v_501.as_canonical_u64() << 24))) + u128::from(((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8) | (__v_110.as_canonical_u64() << 16) | (__v_111.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_502: G = G::from_u8(__u32_bytes[0]);
+    let __v_503: G = G::from_u8(__u32_bytes[1]);
+    let __v_504: G = G::from_u8(__u32_bytes[2]);
+    let __v_505: G = G::from_u8(__u32_bytes[3]);
+    let __v_506: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_502; let __vj = __v_503; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_507: G = G::from_u64(1);
+    let __v_508: G = (__v_506 - __v_507);
+    let __v_509: G = G::from_u64(2);
+    let __v_510: G = (__v_506 - __v_509);
+    let __v_511: G = (__v_508 * __v_510);
+    let __v_512: G = (__v_506 * __v_511);
+    let __v_513: G = G::from_u64(0);
+    if (__v_512 != __v_513) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_514: G = if unconstrained { Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record) };
+    let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) };
+    let __v_516: G = if unconstrained { Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record) };
+    let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) };
+    let __u32_sum: u128 = u128::from(((__v_484.as_canonical_u64() << 0) | (__v_485.as_canonical_u64() << 8) | (__v_486.as_canonical_u64() << 16) | (__v_487.as_canonical_u64() << 24))) + u128::from(((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8) | (__v_517.as_canonical_u64() << 16) | (__v_514.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_518: G = G::from_u8(__u32_bytes[0]);
+    let __v_519: G = G::from_u8(__u32_bytes[1]);
+    let __v_520: G = G::from_u8(__u32_bytes[2]);
+    let __v_521: G = G::from_u8(__u32_bytes[3]);
+    let __v_522: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_520; let __vj = __v_521; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_523: G = (__v_522 * __v_522);
+    if (__v_523 != __v_522) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_522.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record) };
+    let __v_524: G = __b2_out.0;
+    let __v_525: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) };
+    let __v_526: G = __b2_out.0;
+    let __v_527: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) };
+    let __v_528: G = __b2_out.0;
+    let __v_529: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) };
+    let __v_530: G = __b2_out.0;
+    let __v_531: G = __b2_out.1;
+    let __v_532: G = (__v_524 + __v_527);
+    let __v_533: G = (__v_526 + __v_529);
+    let __v_534: G = (__v_528 + __v_531);
+    let __v_535: G = (__v_530 + __v_525);
+    let __u32_sum: u128 = u128::from(((__v_298.as_canonical_u64() << 0) | (__v_299.as_canonical_u64() << 8) | (__v_300.as_canonical_u64() << 16) | (__v_301.as_canonical_u64() << 24))) + u128::from(((__v_396.as_canonical_u64() << 0) | (__v_397.as_canonical_u64() << 8) | (__v_398.as_canonical_u64() << 16) | (__v_399.as_canonical_u64() << 24))) + u128::from(((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8) | (__v_114.as_canonical_u64() << 16) | (__v_115.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_536: G = G::from_u8(__u32_bytes[0]);
+    let __v_537: G = G::from_u8(__u32_bytes[1]);
+    let __v_538: G = G::from_u8(__u32_bytes[2]);
+    let __v_539: G = G::from_u8(__u32_bytes[3]);
+    let __v_540: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_538; let __vj = __v_539; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_541: G = G::from_u64(1);
+    let __v_542: G = (__v_540 - __v_541);
+    let __v_543: G = G::from_u64(2);
+    let __v_544: G = (__v_540 - __v_543);
+    let __v_545: G = (__v_542 * __v_544);
+    let __v_546: G = (__v_540 * __v_545);
+    let __v_547: G = G::from_u64(0);
+    if (__v_546 != __v_547) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_546.as_canonical_u64(), rhs: __v_547.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_548: G = if unconstrained { Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record) };
+    let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) };
+    let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) };
+    let __v_551: G = if unconstrained { Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record) };
+    let __u32_sum: u128 = u128::from(((__v_178.as_canonical_u64() << 0) | (__v_179.as_canonical_u64() << 8) | (__v_180.as_canonical_u64() << 16) | (__v_181.as_canonical_u64() << 24))) + u128::from(((__v_550.as_canonical_u64() << 0) | (__v_551.as_canonical_u64() << 8) | (__v_548.as_canonical_u64() << 16) | (__v_549.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_552: G = G::from_u8(__u32_bytes[0]);
+    let __v_553: G = G::from_u8(__u32_bytes[1]);
+    let __v_554: G = G::from_u8(__u32_bytes[2]);
+    let __v_555: G = G::from_u8(__u32_bytes[3]);
+    let __v_556: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_552; let __vj = __v_553; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_554; let __vj = __v_555; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_557: G = (__v_556 * __v_556);
+    if (__v_557 != __v_556) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_557.as_canonical_u64(), rhs: __v_556.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_142: usize = 25;
-const IN_142: usize = 25;
-const OUT_142: usize = 1;
-fn aiur_fn_142(
-  inp: [G; IN_142],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_142], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_25: G = __loaded[0];
-    let __v_26: G = __loaded[1];
-    let __v_27: G = __loaded[2];
-    let __v_28: G = __loaded[3];
-    match __v_25.as_canonical_u64() {
-      1u64 => {
-        let __v_29: G = G::from_u64(1);
-        let __ret: [G; OUT_142] = [__v_29];
-        if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
-        let __v_31: G = __r_arr[2];
-        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
-        let __v_32: G = __r_arr[0];
-        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
-        let __v_33: G = __r_arr[0];
-        let __ret: [G; OUT_142] = [__v_33];
-        if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
-      },
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record) };
+    let __v_558: G = __b2_out.0;
+    let __v_559: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) };
+    let __v_560: G = __b2_out.0;
+    let __v_561: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) };
+    let __v_562: G = __b2_out.0;
+    let __v_563: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) };
+    let __v_564: G = __b2_out.0;
+    let __v_565: G = __b2_out.1;
+    let __v_566: G = (__v_560 + __v_563);
+    let __v_567: G = (__v_562 + __v_565);
+    let __v_568: G = (__v_564 + __v_559);
+    let __v_569: G = (__v_558 + __v_561);
+    let __u32_sum: u128 = u128::from(((__v_536.as_canonical_u64() << 0) | (__v_537.as_canonical_u64() << 8) | (__v_538.as_canonical_u64() << 16) | (__v_539.as_canonical_u64() << 24))) + u128::from(((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8) | (__v_568.as_canonical_u64() << 16) | (__v_569.as_canonical_u64() << 24))) + u128::from(((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8) | (__v_118.as_canonical_u64() << 16) | (__v_119.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_570: G = G::from_u8(__u32_bytes[0]);
+    let __v_571: G = G::from_u8(__u32_bytes[1]);
+    let __v_572: G = G::from_u8(__u32_bytes[2]);
+    let __v_573: G = G::from_u8(__u32_bytes[3]);
+    let __v_574: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_570; let __vj = __v_571; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_572; let __vj = __v_573; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_575: G = G::from_u64(1);
+    let __v_576: G = (__v_574 - __v_575);
+    let __v_577: G = G::from_u64(2);
+    let __v_578: G = (__v_574 - __v_577);
+    let __v_579: G = (__v_576 * __v_578);
+    let __v_580: G = (__v_574 * __v_579);
+    let __v_581: G = G::from_u64(0);
+    if (__v_580 != __v_581) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_580.as_canonical_u64(), rhs: __v_581.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_582: G = if unconstrained { Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record) };
+    let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) };
+    let __v_584: G = if unconstrained { Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record) };
+    let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) };
+    let __u32_sum: u128 = u128::from(((__v_552.as_canonical_u64() << 0) | (__v_553.as_canonical_u64() << 8) | (__v_554.as_canonical_u64() << 16) | (__v_555.as_canonical_u64() << 24))) + u128::from(((__v_583.as_canonical_u64() << 0) | (__v_584.as_canonical_u64() << 8) | (__v_585.as_canonical_u64() << 16) | (__v_582.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_586: G = G::from_u8(__u32_bytes[0]);
+    let __v_587: G = G::from_u8(__u32_bytes[1]);
+    let __v_588: G = G::from_u8(__u32_bytes[2]);
+    let __v_589: G = G::from_u8(__u32_bytes[3]);
+    let __v_590: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_586; let __vj = __v_587; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_588; let __vj = __v_589; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_591: G = (__v_590 * __v_590);
+    if (__v_591 != __v_590) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_590.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record) };
+    let __v_592: G = __b2_out.0;
+    let __v_593: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) };
+    let __v_594: G = __b2_out.0;
+    let __v_595: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) };
+    let __v_596: G = __b2_out.0;
+    let __v_597: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) };
+    let __v_598: G = __b2_out.0;
+    let __v_599: G = __b2_out.1;
+    let __v_600: G = (__v_592 + __v_595);
+    let __v_601: G = (__v_594 + __v_597);
+    let __v_602: G = (__v_596 + __v_599);
+    let __v_603: G = (__v_598 + __v_593);
+    let __u32_sum: u128 = u128::from(((__v_366.as_canonical_u64() << 0) | (__v_367.as_canonical_u64() << 8) | (__v_368.as_canonical_u64() << 16) | (__v_369.as_canonical_u64() << 24))) + u128::from(((__v_192.as_canonical_u64() << 0) | (__v_193.as_canonical_u64() << 8) | (__v_194.as_canonical_u64() << 16) | (__v_195.as_canonical_u64() << 24))) + u128::from(((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8) | (__v_122.as_canonical_u64() << 16) | (__v_123.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_604: G = G::from_u8(__u32_bytes[0]);
+    let __v_605: G = G::from_u8(__u32_bytes[1]);
+    let __v_606: G = G::from_u8(__u32_bytes[2]);
+    let __v_607: G = G::from_u8(__u32_bytes[3]);
+    let __v_608: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_604; let __vj = __v_605; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_606; let __vj = __v_607; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_609: G = G::from_u64(1);
+    let __v_610: G = (__v_608 - __v_609);
+    let __v_611: G = G::from_u64(2);
+    let __v_612: G = (__v_608 - __v_611);
+    let __v_613: G = (__v_610 * __v_612);
+    let __v_614: G = (__v_608 * __v_613);
+    let __v_615: G = G::from_u64(0);
+    if (__v_614 != __v_615) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_615.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_143: usize = 31;
-const IN_143: usize = 31;
-const OUT_143: usize = 1;
-fn aiur_fn_143(
-  inp: [G; IN_143],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_143], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    match __v_6.as_canonical_u64() {
-      _ => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-        let __v_31: G = __r_arr[0];
-        let __v_32: G = G::from_u64(1);
-        let __v_33: G = G::from_u64(1);
-        let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() {
-  0u64 => {
-    break '__mc_0 [__v_34];
-  },
-  1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    break '__mc_0 [__v_35];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-  },
-}
- };
-        let __v_35: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-        let __v_39: G = __r_arr[0];
-        let __v_40: G = G::from_u64(1);
-        let __v_41: G = G::from_u64(1);
-        let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-        let __v_43: G = __r_arr[0];
-        let __v_44: G = __r_arr[1];
-        let __v_45: G = __r_arr[2];
-        let __v_46: G = __r_arr[3];
-        let __v_47: G = __r_arr[4];
-        let __v_48: G = __r_arr[5];
-        let __v_49: G = __r_arr[6];
-        let __v_50: G = __r_arr[7];
-        let __v_51: G = __r_arr[8];
-        let __v_52: G = __r_arr[9];
-        let __v_53: G = __r_arr[10];
-        let __v_54: G = __r_arr[11];
-        let __v_55: G = __r_arr[12];
-        let __v_56: G = __r_arr[13];
-        let __v_57: G = __r_arr[14];
-        let __v_58: G = __r_arr[15];
-        let __v_59: G = __r_arr[16];
-        let __v_60: G = __r_arr[17];
-        let __v_61: G = G::from_u64(256);
-        let __v_62: G = (__v_61 * __v_44);
-        let __v_63: G = G::from_u64(65536);
-        let __v_64: G = (__v_63 * __v_45);
-        let __v_65: G = G::from_u64(16777216);
-        let __v_66: G = (__v_65 * __v_46);
-        let __v_67: G = G::from_u64(4294967296);
-        let __v_68: G = (__v_67 * __v_47);
-        let __v_69: G = G::from_u64(1099511627776);
-        let __v_70: G = (__v_69 * __v_48);
-        let __v_71: G = G::from_u64(281474976710656);
-        let __v_72: G = (__v_71 * __v_49);
-        let __v_73: G = G::from_u64(72057594037927936);
-        let __v_74: G = (__v_73 * __v_50);
-        let __v_75: G = (__v_72 + __v_74);
-        let __v_76: G = (__v_70 + __v_75);
-        let __v_77: G = (__v_68 + __v_76);
-        let __v_78: G = (__v_66 + __v_77);
-        let __v_79: G = (__v_64 + __v_78);
-        let __v_80: G = (__v_62 + __v_79);
-        let __v_81: G = (__v_43 + __v_80);
-        let __v_82: G = G::from_u64(256);
-        let __v_83: G = (__v_82 * __v_52);
-        let __v_84: G = G::from_u64(65536);
-        let __v_85: G = (__v_84 * __v_53);
-        let __v_86: G = G::from_u64(16777216);
-        let __v_87: G = (__v_86 * __v_54);
-        let __v_88: G = G::from_u64(4294967296);
-        let __v_89: G = (__v_88 * __v_55);
-        let __v_90: G = G::from_u64(1099511627776);
-        let __v_91: G = (__v_90 * __v_56);
-        let __v_92: G = G::from_u64(281474976710656);
-        let __v_93: G = (__v_92 * __v_57);
-        let __v_94: G = G::from_u64(72057594037927936);
-        let __v_95: G = (__v_94 * __v_58);
-        let __v_96: G = (__v_93 + __v_95);
-        let __v_97: G = (__v_91 + __v_96);
-        let __v_98: G = (__v_89 + __v_97);
-        let __v_99: G = (__v_87 + __v_98);
-        let __v_100: G = (__v_85 + __v_99);
-        let __v_101: G = (__v_83 + __v_100);
-        let __v_102: G = (__v_51 + __v_101);
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-        let __v_103: G = __r_arr[0];
-        let __v_104: G = __r_arr[1];
-        let __v_105: G = G::from_u64(1);
-        let __v_106: G = G::from_u64(1);
-        let __v_107: G = { let __values: [G; 3] = [__v_105, __v_106, __v_106]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-        let __v_108: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_104, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-        let __v_109: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_109, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
-        let __v_110: G = __r_arr[0];
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_110, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
-        let __v_111: G = __r_arr[0];
-        let __v_112: G = __r_arr[1];
-        let __v_113: G = (__v_31 + __v_27);
-        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-        let __v_114: G = __r_arr[0];
-        let __v_115: G = (__v_114 - __v_31);
-        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
-        let __v_117: G = G::from_u64(1);
-        if (__v_116 != __v_117) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_116.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_118: G = __r_arr[0];
-        let __v_119: G = (__v_118 - __v_28);
-        let __v_120: G = G::from_bool((__v_119 == G::ZERO));
-        let __v_121: G = G::from_u64(1);
-        if (__v_120 != __v_121) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_121.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_122: G = __r_arr[0];
-        let __v_123: G = G::from_u64(1);
-        if (__v_122 != __v_123) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_122.as_canonical_u64(), rhs: __v_123.as_canonical_u64(), msg: None });
-        }
-        let __v_124: G = G::from_u64(33);
-        let __v_125: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_124.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-        let __v_126: G = G::from_u64(1);
-        if (__v_125 != __v_126) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_111, __v_112, __v_8, __v_81, __v_102, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_113, __v_103, __v_6, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
-        let __v_127: G = __r_arr[0];
-        let __ret: [G; OUT_143] = [__v_127];
-        if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    let __v_616: G = if unconstrained { Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record) };
+    let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) };
+    let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) };
+    let __v_619: G = if unconstrained { Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record) };
+    let __u32_sum: u128 = u128::from(((__v_246.as_canonical_u64() << 0) | (__v_247.as_canonical_u64() << 8) | (__v_248.as_canonical_u64() << 16) | (__v_249.as_canonical_u64() << 24))) + u128::from(((__v_618.as_canonical_u64() << 0) | (__v_619.as_canonical_u64() << 8) | (__v_616.as_canonical_u64() << 16) | (__v_617.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_620: G = G::from_u8(__u32_bytes[0]);
+    let __v_621: G = G::from_u8(__u32_bytes[1]);
+    let __v_622: G = G::from_u8(__u32_bytes[2]);
+    let __v_623: G = G::from_u8(__u32_bytes[3]);
+    let __v_624: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_620; let __vj = __v_621; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_622; let __vj = __v_623; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_625: G = (__v_624 * __v_624);
+    if (__v_625 != __v_624) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_625.as_canonical_u64(), rhs: __v_624.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_144: usize = 2;
-const IN_144: usize = 2;
-const OUT_144: usize = 1;
-fn aiur_fn_144(
-  inp: [G; IN_144],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_144], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = G::from_bool((__v_0 == G::ZERO));
-    let __v_3: G = G::from_bool((__v_1 == G::ZERO));
-    let __v_4: G = (__v_2 * __v_3);
-    let __ret: [G; OUT_144] = [__v_4];
-    if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_145: usize = 1;
-const IN_145: usize = 1;
-const OUT_145: usize = 1;
-fn aiur_fn_145(
-  inp: [G; IN_145],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_145], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_145] = [__v_5];
-        if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_bool((__v_2 == G::ZERO));
-            let __v_10: G = G::from_bool((__v_3 == G::ZERO));
-            let __v_11: G = (__v_9 * __v_10);
-            let __ret: [G; OUT_145] = [__v_11];
-            if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_145] = [__v_9];
-            if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record) };
+    let __v_626: G = __b2_out.0;
+    let __v_627: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) };
+    let __v_628: G = __b2_out.0;
+    let __v_629: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) };
+    let __v_630: G = __b2_out.0;
+    let __v_631: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) };
+    let __v_632: G = __b2_out.0;
+    let __v_633: G = __b2_out.1;
+    let __v_634: G = (__v_628 + __v_631);
+    let __v_635: G = (__v_630 + __v_633);
+    let __v_636: G = (__v_632 + __v_627);
+    let __v_637: G = (__v_626 + __v_629);
+    let __u32_sum: u128 = u128::from(((__v_604.as_canonical_u64() << 0) | (__v_605.as_canonical_u64() << 8) | (__v_606.as_canonical_u64() << 16) | (__v_607.as_canonical_u64() << 24))) + u128::from(((__v_634.as_canonical_u64() << 0) | (__v_635.as_canonical_u64() << 8) | (__v_636.as_canonical_u64() << 16) | (__v_637.as_canonical_u64() << 24))) + u128::from(((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8) | (__v_126.as_canonical_u64() << 16) | (__v_127.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_638: G = G::from_u8(__u32_bytes[0]);
+    let __v_639: G = G::from_u8(__u32_bytes[1]);
+    let __v_640: G = G::from_u8(__u32_bytes[2]);
+    let __v_641: G = G::from_u8(__u32_bytes[3]);
+    let __v_642: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_638; let __vj = __v_639; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_640; let __vj = __v_641; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_643: G = G::from_u64(1);
+    let __v_644: G = (__v_642 - __v_643);
+    let __v_645: G = G::from_u64(2);
+    let __v_646: G = (__v_642 - __v_645);
+    let __v_647: G = (__v_644 * __v_646);
+    let __v_648: G = (__v_642 * __v_647);
+    let __v_649: G = G::from_u64(0);
+    if (__v_648 != __v_649) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_146: usize = 9;
-const IN_146: usize = 9;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_146], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(0);
-    let __v_13: G = G::from_u64(0);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_146] = [__v_24];
-    if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_650: G = if unconstrained { Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record) };
+    let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) };
+    let __v_652: G = if unconstrained { Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record) };
+    let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) };
+    let __u32_sum: u128 = u128::from(((__v_620.as_canonical_u64() << 0) | (__v_621.as_canonical_u64() << 8) | (__v_622.as_canonical_u64() << 16) | (__v_623.as_canonical_u64() << 24))) + u128::from(((__v_651.as_canonical_u64() << 0) | (__v_652.as_canonical_u64() << 8) | (__v_653.as_canonical_u64() << 16) | (__v_650.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_654: G = G::from_u8(__u32_bytes[0]);
+    let __v_655: G = G::from_u8(__u32_bytes[1]);
+    let __v_656: G = G::from_u8(__u32_bytes[2]);
+    let __v_657: G = G::from_u8(__u32_bytes[3]);
+    let __v_658: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_654; let __vj = __v_655; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_656; let __vj = __v_657; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_659: G = (__v_658 * __v_658);
+    if (__v_659 != __v_658) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_658.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record) };
+    let __v_660: G = __b2_out.0;
+    let __v_661: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) };
+    let __v_662: G = __b2_out.0;
+    let __v_663: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) };
+    let __v_664: G = __b2_out.0;
+    let __v_665: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) };
+    let __v_666: G = __b2_out.0;
+    let __v_667: G = __b2_out.1;
+    let __v_668: G = (__v_660 + __v_663);
+    let __v_669: G = (__v_662 + __v_665);
+    let __v_670: G = (__v_664 + __v_667);
+    let __v_671: G = (__v_666 + __v_661);
+    let __ret: [G; OUT_81] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127];
+    if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_147: usize = 33;
-const IN_147: usize = 33;
-const OUT_147: usize = 1;
-fn aiur_fn_147(
-  inp: [G; IN_147],
+const INPUT_SIZE_82: usize = 106;
+const IN_82: usize = 106;
+const OUT_82: usize = 32;
+fn aiur_fn_82(
+  inp: [G; IN_82],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_147], ExecError> {
+) -> Result<[G; OUT_82], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13872,563 +6935,1750 @@ fn aiur_fn_147(
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_36: G = __r_arr[0];
-    let __ret: [G; OUT_147] = [__v_36];
-    if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_148: usize = 2;
-const IN_148: usize = 2;
-const OUT_148: usize = 1;
-fn aiur_fn_148(
-  inp: [G; IN_148],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_148], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_148] = [__v_1];
-        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        let __v_9: G = __loaded[4];
-        let __v_10: G = __loaded[5];
-        let __v_11: G = __loaded[6];
-        let __v_12: G = __loaded[7];
-        let __v_13: G = __loaded[8];
-        let __v_14: G = __loaded[9];
-        let __v_15: G = __loaded[10];
-        let __v_16: G = __loaded[11];
-        let __v_17: G = __loaded[12];
-        let __v_18: G = __loaded[13];
-        let __v_19: G = __loaded[14];
-        let __v_20: G = __loaded[15];
-        let __v_21: G = __loaded[16];
-        let __v_22: G = __loaded[17];
-        let __v_23: G = __loaded[18];
-        let __v_24: G = __loaded[19];
-        let __v_25: G = __loaded[20];
-        let __v_26: G = __loaded[21];
-        let __v_27: G = __loaded[22];
-        let __v_28: G = __loaded[23];
-        let __v_29: G = __loaded[24];
-        let __v_30: G = __loaded[25];
-        let __v_31: G = __loaded[26];
-        let __v_32: G = __loaded[27];
-        let __v_33: G = __loaded[28];
-        let __v_34: G = __loaded[29];
-        let __v_35: G = __loaded[30];
-        let __v_36: G = __loaded[31];
-        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-        let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_40: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_41: G = __r_arr[0];
-        let __ret: [G; OUT_148] = [__v_41];
-        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_149: usize = 2;
-const IN_149: usize = 2;
-const OUT_149: usize = 1;
-fn aiur_fn_149(
-  inp: [G; IN_149],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_149], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_149] = [__v_1];
-        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_149] = [__v_13];
-        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = inp[57];
+    let __v_58: G = inp[58];
+    let __v_59: G = inp[59];
+    let __v_60: G = inp[60];
+    let __v_61: G = inp[61];
+    let __v_62: G = inp[62];
+    let __v_63: G = inp[63];
+    let __v_64: G = inp[64];
+    let __v_65: G = inp[65];
+    let __v_66: G = inp[66];
+    let __v_67: G = inp[67];
+    let __v_68: G = inp[68];
+    let __v_69: G = inp[69];
+    let __v_70: G = inp[70];
+    let __v_71: G = inp[71];
+    let __v_72: G = inp[72];
+    let __v_73: G = inp[73];
+    let __v_74: G = inp[74];
+    let __v_75: G = inp[75];
+    let __v_76: G = inp[76];
+    let __v_77: G = inp[77];
+    let __v_78: G = inp[78];
+    let __v_79: G = inp[79];
+    let __v_80: G = inp[80];
+    let __v_81: G = inp[81];
+    let __v_82: G = inp[82];
+    let __v_83: G = inp[83];
+    let __v_84: G = inp[84];
+    let __v_85: G = inp[85];
+    let __v_86: G = inp[86];
+    let __v_87: G = inp[87];
+    let __v_88: G = inp[88];
+    let __v_89: G = inp[89];
+    let __v_90: G = inp[90];
+    let __v_91: G = inp[91];
+    let __v_92: G = inp[92];
+    let __v_93: G = inp[93];
+    let __v_94: G = inp[94];
+    let __v_95: G = inp[95];
+    let __v_96: G = inp[96];
+    let __v_97: G = inp[97];
+    let __v_98: G = inp[98];
+    let __v_99: G = inp[99];
+    let __v_100: G = inp[100];
+    let __v_101: G = inp[101];
+    let __v_102: G = inp[102];
+    let __v_103: G = inp[103];
+    let __v_104: G = inp[104];
+    let __v_105: G = inp[105];
+    let __v_106: G = G::from_u64(103);
+    let __v_107: G = G::from_u64(230);
+    let __v_108: G = G::from_u64(9);
+    let __v_109: G = G::from_u64(106);
+    let __v_110: G = G::from_u64(133);
+    let __v_111: G = G::from_u64(174);
+    let __v_112: G = G::from_u64(103);
+    let __v_113: G = G::from_u64(187);
+    let __v_114: G = G::from_u64(114);
+    let __v_115: G = G::from_u64(243);
+    let __v_116: G = G::from_u64(110);
+    let __v_117: G = G::from_u64(60);
+    let __v_118: G = G::from_u64(58);
+    let __v_119: G = G::from_u64(245);
+    let __v_120: G = G::from_u64(79);
+    let __v_121: G = G::from_u64(165);
+    let __v_122: G = G::from_u64(0);
+    let __v_123: G = G::from_u64(0);
+    let __v_124: G = G::from_u64(0);
+    let __v_125: G = G::from_u64(0);
+    let __v_126: G = G::from_u64(0);
+    let __v_127: G = G::from_u64(0);
+    let __v_128: G = G::from_u64(0);
+    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+    let __v_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __v_131: G = __r_arr[2];
+    let __v_132: G = __r_arr[3];
+    let __v_133: G = __r_arr[4];
+    let __v_134: G = __r_arr[5];
+    let __v_135: G = __r_arr[6];
+    let __v_136: G = __r_arr[7];
+    let __v_137: G = __r_arr[8];
+    let __v_138: G = __r_arr[9];
+    let __v_139: G = __r_arr[10];
+    let __v_140: G = __r_arr[11];
+    let __v_141: G = __r_arr[12];
+    let __v_142: G = __r_arr[13];
+    let __v_143: G = __r_arr[14];
+    let __v_144: G = __r_arr[15];
+    let __v_145: G = __r_arr[16];
+    let __v_146: G = __r_arr[17];
+    let __v_147: G = __r_arr[18];
+    let __v_148: G = __r_arr[19];
+    let __v_149: G = __r_arr[20];
+    let __v_150: G = __r_arr[21];
+    let __v_151: G = __r_arr[22];
+    let __v_152: G = __r_arr[23];
+    let __v_153: G = __r_arr[24];
+    let __v_154: G = __r_arr[25];
+    let __v_155: G = __r_arr[26];
+    let __v_156: G = __r_arr[27];
+    let __v_157: G = __r_arr[28];
+    let __v_158: G = __r_arr[29];
+    let __v_159: G = __r_arr[30];
+    let __v_160: G = __r_arr[31];
+    let __ret: [G; OUT_82] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
+    if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_150: usize = 2;
-const IN_150: usize = 2;
-const OUT_150: usize = 10;
-fn aiur_fn_150(
-  inp: [G; IN_150],
+const INPUT_SIZE_83: usize = 129;
+const IN_83: usize = 129;
+const OUT_83: usize = 32;
+fn aiur_fn_83(
+  inp: [G; IN_83],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_150], ExecError> {
+) -> Result<[G; OUT_83], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(103);
-        let __v_6: G = G::from_u64(230);
-        let __v_7: G = G::from_u64(9);
-        let __v_8: G = G::from_u64(106);
-        let __v_9: G = G::from_u64(133);
-        let __v_10: G = G::from_u64(174);
-        let __v_11: G = G::from_u64(103);
-        let __v_12: G = G::from_u64(187);
-        let __v_13: G = G::from_u64(114);
-        let __v_14: G = G::from_u64(243);
-        let __v_15: G = G::from_u64(110);
-        let __v_16: G = G::from_u64(60);
-        let __v_17: G = G::from_u64(58);
-        let __v_18: G = G::from_u64(245);
-        let __v_19: G = G::from_u64(79);
-        let __v_20: G = G::from_u64(165);
-        let __v_21: G = G::from_u64(127);
-        let __v_22: G = G::from_u64(82);
-        let __v_23: G = G::from_u64(14);
-        let __v_24: G = G::from_u64(81);
-        let __v_25: G = G::from_u64(140);
-        let __v_26: G = G::from_u64(104);
-        let __v_27: G = G::from_u64(5);
-        let __v_28: G = G::from_u64(155);
-        let __v_29: G = G::from_u64(171);
-        let __v_30: G = G::from_u64(217);
-        let __v_31: G = G::from_u64(131);
-        let __v_32: G = G::from_u64(31);
-        let __v_33: G = G::from_u64(25);
-        let __v_34: G = G::from_u64(205);
-        let __v_35: G = G::from_u64(224);
-        let __v_36: G = G::from_u64(91);
-        let __v_37: G = G::from_u64(1);
-        let __v_38: G = G::from_u64(1);
-        let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_40: G = G::from_u64(0);
-        let __v_41: G = G::from_u64(0);
-        let __v_42: G = G::from_u64(0);
-        let __v_43: G = G::from_u64(0);
-        let __v_44: G = G::from_u64(0);
-        let __v_45: G = G::from_u64(0);
-        let __v_46: G = G::from_u64(0);
-        let __v_47: G = G::from_u64(0);
-        let __v_48: G = G::from_u64(0);
-        let __v_49: G = G::from_u64(0);
-        let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_52: G = G::from_u64(1);
-        let __v_53: G = G::from_u64(1);
-        let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-        let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
-        let __v_56: G = __r_arr[0];
-        let __v_57: G = __r_arr[1];
-        let __v_58: G = __r_arr[2];
-        let __v_59: G = __r_arr[3];
-        let __v_60: G = __r_arr[4];
-        let __v_61: G = __r_arr[5];
-        let __v_62: G = __r_arr[6];
-        let __v_63: G = __r_arr[7];
-        let __v_64: G = __r_arr[8];
-        let __v_65: G = __r_arr[9];
-        let __v_66: G = __r_arr[10];
-        let __v_67: G = __r_arr[11];
-        let __v_68: G = __r_arr[12];
-        let __v_69: G = __r_arr[13];
-        let __v_70: G = __r_arr[14];
-        let __v_71: G = __r_arr[15];
-        let __v_72: G = __r_arr[16];
-        let __v_73: G = __r_arr[17];
-        let __v_74: G = __r_arr[18];
-        let __v_75: G = __r_arr[19];
-        let __v_76: G = __r_arr[20];
-        let __v_77: G = __r_arr[21];
-        let __v_78: G = __r_arr[22];
-        let __v_79: G = __r_arr[23];
-        let __v_80: G = __r_arr[24];
-        let __v_81: G = __r_arr[25];
-        let __v_82: G = __r_arr[26];
-        let __v_83: G = __r_arr[27];
-        let __v_84: G = __r_arr[28];
-        let __v_85: G = __r_arr[29];
-        let __v_86: G = __r_arr[30];
-        let __v_87: G = __r_arr[31];
-        let __v_88: G = G::from_u64(1);
-        let __v_89: G = G::from_u64(1);
-        let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_91: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_92: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_93: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_94: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_95: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_96: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_97: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_98: G = __r_arr[0];
-        let __v_99: G = G::from_u64(1);
-        let __v_100: G = G::from_u64(1);
-        let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-        let __v_102: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_103: G = __loaded[0];
-        let __v_104: G = __loaded[1];
-        let __v_105: G = __loaded[2];
-        match __v_103.as_canonical_u64() {
-          0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_106: G = __loaded[0];
-            let __v_107: G = __loaded[1];
-            let __v_108: G = __loaded[2];
-            match __v_106.as_canonical_u64() {
-              0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_109: G = __loaded[0];
-                let __v_110: G = __loaded[1];
-                let __v_111: G = __loaded[2];
-                match __v_109.as_canonical_u64() {
-                  0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_112: G = __loaded[0];
-                    let __v_113: G = __loaded[1];
-                    let __v_114: G = __loaded[2];
-                    match __v_112.as_canonical_u64() {
-                      0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_115: G = __loaded[0];
-                        let __v_116: G = __loaded[1];
-                        let __v_117: G = __loaded[2];
-                        match __v_115.as_canonical_u64() {
-                          0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_118: G = __loaded[0];
-                            let __v_119: G = __loaded[1];
-                            let __v_120: G = __loaded[2];
-                            match __v_118.as_canonical_u64() {
-                              0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                let __v_121: G = __loaded[0];
-                                let __v_122: G = __loaded[1];
-                                let __v_123: G = __loaded[2];
-                                match __v_121.as_canonical_u64() {
-                                  0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                    let __v_124: G = __loaded[0];
-                                    let __v_125: G = __loaded[1];
-                                    let __v_126: G = __loaded[2];
-                                    match __v_124.as_canonical_u64() {
-                                      0u64 => {
-                                        let __ret: [G; OUT_150] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126];
-                                        if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                        return Ok(__ret);
-                                      },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
-          },
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = inp[57];
+    let __v_58: G = inp[58];
+    let __v_59: G = inp[59];
+    let __v_60: G = inp[60];
+    let __v_61: G = inp[61];
+    let __v_62: G = inp[62];
+    let __v_63: G = inp[63];
+    let __v_64: G = inp[64];
+    let __v_65: G = inp[65];
+    let __v_66: G = inp[66];
+    let __v_67: G = inp[67];
+    let __v_68: G = inp[68];
+    let __v_69: G = inp[69];
+    let __v_70: G = inp[70];
+    let __v_71: G = inp[71];
+    let __v_72: G = inp[72];
+    let __v_73: G = inp[73];
+    let __v_74: G = inp[74];
+    let __v_75: G = inp[75];
+    let __v_76: G = inp[76];
+    let __v_77: G = inp[77];
+    let __v_78: G = inp[78];
+    let __v_79: G = inp[79];
+    let __v_80: G = inp[80];
+    let __v_81: G = inp[81];
+    let __v_82: G = inp[82];
+    let __v_83: G = inp[83];
+    let __v_84: G = inp[84];
+    let __v_85: G = inp[85];
+    let __v_86: G = inp[86];
+    let __v_87: G = inp[87];
+    let __v_88: G = inp[88];
+    let __v_89: G = inp[89];
+    let __v_90: G = inp[90];
+    let __v_91: G = inp[91];
+    let __v_92: G = inp[92];
+    let __v_93: G = inp[93];
+    let __v_94: G = inp[94];
+    let __v_95: G = inp[95];
+    let __v_96: G = inp[96];
+    let __v_97: G = inp[97];
+    let __v_98: G = inp[98];
+    let __v_99: G = inp[99];
+    let __v_100: G = inp[100];
+    let __v_101: G = inp[101];
+    let __v_102: G = inp[102];
+    let __v_103: G = inp[103];
+    let __v_104: G = inp[104];
+    let __v_105: G = inp[105];
+    let __v_106: G = inp[106];
+    let __v_107: G = inp[107];
+    let __v_108: G = inp[108];
+    let __v_109: G = inp[109];
+    let __v_110: G = inp[110];
+    let __v_111: G = inp[111];
+    let __v_112: G = inp[112];
+    let __v_113: G = inp[113];
+    let __v_114: G = inp[114];
+    let __v_115: G = inp[115];
+    let __v_116: G = inp[116];
+    let __v_117: G = inp[117];
+    let __v_118: G = inp[118];
+    let __v_119: G = inp[119];
+    let __v_120: G = inp[120];
+    let __v_121: G = inp[121];
+    let __v_122: G = inp[122];
+    let __v_123: G = inp[123];
+    let __v_124: G = inp[124];
+    let __v_125: G = inp[125];
+    let __v_126: G = inp[126];
+    let __v_127: G = inp[127];
+    let __v_128: G = inp[128];
+    match __v_0.as_canonical_u64() {
+      7u64 => {
+        let __v_129: G = if unconstrained { Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record) };
+        let __v_130: G = if unconstrained { Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record) };
+        let __v_131: G = if unconstrained { Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record) };
+        let __v_132: G = if unconstrained { Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record) };
+        let __v_133: G = if unconstrained { Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record) };
+        let __v_134: G = if unconstrained { Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record) };
+        let __v_135: G = if unconstrained { Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record) };
+        let __v_136: G = if unconstrained { Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record) };
+        let __v_137: G = if unconstrained { Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record) };
+        let __v_138: G = if unconstrained { Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record) };
+        let __v_139: G = if unconstrained { Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record) };
+        let __v_140: G = if unconstrained { Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record) };
+        let __v_141: G = if unconstrained { Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record) };
+        let __v_142: G = if unconstrained { Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record) };
+        let __v_143: G = if unconstrained { Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record) };
+        let __v_144: G = if unconstrained { Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record) };
+        let __v_145: G = if unconstrained { Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record) };
+        let __v_146: G = if unconstrained { Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record) };
+        let __v_147: G = if unconstrained { Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record) };
+        let __v_148: G = if unconstrained { Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record) };
+        let __v_149: G = if unconstrained { Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record) };
+        let __v_150: G = if unconstrained { Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record) };
+        let __v_151: G = if unconstrained { Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record) };
+        let __v_152: G = if unconstrained { Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record) };
+        let __v_153: G = if unconstrained { Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record) };
+        let __v_154: G = if unconstrained { Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record) };
+        let __v_155: G = if unconstrained { Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record) };
+        let __v_156: G = if unconstrained { Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record) };
+        let __v_157: G = if unconstrained { Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record) };
+        let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) };
+        let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) };
+        let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) };
+        let __ret: [G; OUT_83] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
+        if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __u32_sum: u128 = u128::from(((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8) | (__v_3.as_canonical_u64() << 16) | (__v_4.as_canonical_u64() << 24))) + u128::from(((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8) | (__v_19.as_canonical_u64() << 16) | (__v_20.as_canonical_u64() << 24))) + u128::from(((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8) | (__v_67.as_canonical_u64() << 16) | (__v_68.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_129: G = G::from_u8(__u32_bytes[0]);
+        let __v_130: G = G::from_u8(__u32_bytes[1]);
+        let __v_131: G = G::from_u8(__u32_bytes[2]);
+        let __v_132: G = G::from_u8(__u32_bytes[3]);
+        let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_134: G = G::from_u64(1);
+        let __v_135: G = (__v_133 - __v_134);
+        let __v_136: G = G::from_u64(2);
+        let __v_137: G = (__v_133 - __v_136);
+        let __v_138: G = (__v_135 * __v_137);
+        let __v_139: G = (__v_133 * __v_138);
+        let __v_140: G = G::from_u64(0);
+        if (__v_139 != __v_140) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) };
+        let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) };
+        let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) };
+        let __v_144: G = if unconstrained { Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record) };
+        let __u32_sum: u128 = u128::from(((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8) | (__v_35.as_canonical_u64() << 16) | (__v_36.as_canonical_u64() << 24))) + u128::from(((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8) | (__v_141.as_canonical_u64() << 16) | (__v_142.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_145: G = G::from_u8(__u32_bytes[0]);
+        let __v_146: G = G::from_u8(__u32_bytes[1]);
+        let __v_147: G = G::from_u8(__u32_bytes[2]);
+        let __v_148: G = G::from_u8(__u32_bytes[3]);
+        let __v_149: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_150: G = (__v_149 * __v_149);
+        if (__v_150 != __v_149) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) };
+        let __v_151: G = __b2_out.0;
+        let __v_152: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) };
+        let __v_153: G = __b2_out.0;
+        let __v_154: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) };
+        let __v_155: G = __b2_out.0;
+        let __v_156: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record) };
+        let __v_157: G = __b2_out.0;
+        let __v_158: G = __b2_out.1;
+        let __v_159: G = (__v_153 + __v_156);
+        let __v_160: G = (__v_155 + __v_158);
+        let __v_161: G = (__v_157 + __v_152);
+        let __v_162: G = (__v_151 + __v_154);
+        let __u32_sum: u128 = u128::from(((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8) | (__v_131.as_canonical_u64() << 16) | (__v_132.as_canonical_u64() << 24))) + u128::from(((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8) | (__v_161.as_canonical_u64() << 16) | (__v_162.as_canonical_u64() << 24))) + u128::from(((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8) | (__v_71.as_canonical_u64() << 16) | (__v_72.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_163: G = G::from_u8(__u32_bytes[0]);
+        let __v_164: G = G::from_u8(__u32_bytes[1]);
+        let __v_165: G = G::from_u8(__u32_bytes[2]);
+        let __v_166: G = G::from_u8(__u32_bytes[3]);
+        let __v_167: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_168: G = G::from_u64(1);
+        let __v_169: G = (__v_167 - __v_168);
+        let __v_170: G = G::from_u64(2);
+        let __v_171: G = (__v_167 - __v_170);
+        let __v_172: G = (__v_169 * __v_171);
+        let __v_173: G = (__v_167 * __v_172);
+        let __v_174: G = G::from_u64(0);
+        if (__v_173 != __v_174) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_174.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) };
+        let __v_176: G = if unconstrained { Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record) };
+        let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) };
+        let __v_178: G = if unconstrained { Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record) };
+        let __u32_sum: u128 = u128::from(((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8) | (__v_147.as_canonical_u64() << 16) | (__v_148.as_canonical_u64() << 24))) + u128::from(((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8) | (__v_178.as_canonical_u64() << 16) | (__v_175.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_179: G = G::from_u8(__u32_bytes[0]);
+        let __v_180: G = G::from_u8(__u32_bytes[1]);
+        let __v_181: G = G::from_u8(__u32_bytes[2]);
+        let __v_182: G = G::from_u8(__u32_bytes[3]);
+        let __v_183: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_179; let __vj = __v_180; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_181; let __vj = __v_182; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_184: G = (__v_183 * __v_183);
+        if (__v_184 != __v_183) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) };
+        let __v_185: G = __b2_out.0;
+        let __v_186: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) };
+        let __v_187: G = __b2_out.0;
+        let __v_188: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) };
+        let __v_189: G = __b2_out.0;
+        let __v_190: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record) };
+        let __v_191: G = __b2_out.0;
+        let __v_192: G = __b2_out.1;
+        let __v_193: G = (__v_185 + __v_188);
+        let __v_194: G = (__v_187 + __v_190);
+        let __v_195: G = (__v_189 + __v_192);
+        let __v_196: G = (__v_191 + __v_186);
+        let __u32_sum: u128 = u128::from(((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8) | (__v_7.as_canonical_u64() << 16) | (__v_8.as_canonical_u64() << 24))) + u128::from(((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8) | (__v_23.as_canonical_u64() << 16) | (__v_24.as_canonical_u64() << 24))) + u128::from(((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8) | (__v_75.as_canonical_u64() << 16) | (__v_76.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_197: G = G::from_u8(__u32_bytes[0]);
+        let __v_198: G = G::from_u8(__u32_bytes[1]);
+        let __v_199: G = G::from_u8(__u32_bytes[2]);
+        let __v_200: G = G::from_u8(__u32_bytes[3]);
+        let __v_201: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_197; let __vj = __v_198; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_199; let __vj = __v_200; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_202: G = G::from_u64(1);
+        let __v_203: G = (__v_201 - __v_202);
+        let __v_204: G = G::from_u64(2);
+        let __v_205: G = (__v_201 - __v_204);
+        let __v_206: G = (__v_203 * __v_205);
+        let __v_207: G = (__v_201 * __v_206);
+        let __v_208: G = G::from_u64(0);
+        if (__v_207 != __v_208) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_208.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) };
+        let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) };
+        let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) };
+        let __v_212: G = if unconstrained { Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record) };
+        let __u32_sum: u128 = u128::from(((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8) | (__v_39.as_canonical_u64() << 16) | (__v_40.as_canonical_u64() << 24))) + u128::from(((__v_211.as_canonical_u64() << 0) | (__v_212.as_canonical_u64() << 8) | (__v_209.as_canonical_u64() << 16) | (__v_210.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_213: G = G::from_u8(__u32_bytes[0]);
+        let __v_214: G = G::from_u8(__u32_bytes[1]);
+        let __v_215: G = G::from_u8(__u32_bytes[2]);
+        let __v_216: G = G::from_u8(__u32_bytes[3]);
+        let __v_217: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_213; let __vj = __v_214; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_215; let __vj = __v_216; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_218: G = (__v_217 * __v_217);
+        if (__v_218 != __v_217) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_217.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) };
+        let __v_219: G = __b2_out.0;
+        let __v_220: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) };
+        let __v_221: G = __b2_out.0;
+        let __v_222: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) };
+        let __v_223: G = __b2_out.0;
+        let __v_224: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record) };
+        let __v_225: G = __b2_out.0;
+        let __v_226: G = __b2_out.1;
+        let __v_227: G = (__v_221 + __v_224);
+        let __v_228: G = (__v_223 + __v_226);
+        let __v_229: G = (__v_225 + __v_220);
+        let __v_230: G = (__v_219 + __v_222);
+        let __u32_sum: u128 = u128::from(((__v_197.as_canonical_u64() << 0) | (__v_198.as_canonical_u64() << 8) | (__v_199.as_canonical_u64() << 16) | (__v_200.as_canonical_u64() << 24))) + u128::from(((__v_227.as_canonical_u64() << 0) | (__v_228.as_canonical_u64() << 8) | (__v_229.as_canonical_u64() << 16) | (__v_230.as_canonical_u64() << 24))) + u128::from(((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8) | (__v_79.as_canonical_u64() << 16) | (__v_80.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_231: G = G::from_u8(__u32_bytes[0]);
+        let __v_232: G = G::from_u8(__u32_bytes[1]);
+        let __v_233: G = G::from_u8(__u32_bytes[2]);
+        let __v_234: G = G::from_u8(__u32_bytes[3]);
+        let __v_235: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_236: G = G::from_u64(1);
+        let __v_237: G = (__v_235 - __v_236);
+        let __v_238: G = G::from_u64(2);
+        let __v_239: G = (__v_235 - __v_238);
+        let __v_240: G = (__v_237 * __v_239);
+        let __v_241: G = (__v_235 * __v_240);
+        let __v_242: G = G::from_u64(0);
+        if (__v_241 != __v_242) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) };
+        let __v_244: G = if unconstrained { Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record) };
+        let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) };
+        let __v_246: G = if unconstrained { Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record) };
+        let __u32_sum: u128 = u128::from(((__v_213.as_canonical_u64() << 0) | (__v_214.as_canonical_u64() << 8) | (__v_215.as_canonical_u64() << 16) | (__v_216.as_canonical_u64() << 24))) + u128::from(((__v_244.as_canonical_u64() << 0) | (__v_245.as_canonical_u64() << 8) | (__v_246.as_canonical_u64() << 16) | (__v_243.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_247: G = G::from_u8(__u32_bytes[0]);
+        let __v_248: G = G::from_u8(__u32_bytes[1]);
+        let __v_249: G = G::from_u8(__u32_bytes[2]);
+        let __v_250: G = G::from_u8(__u32_bytes[3]);
+        let __v_251: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_247; let __vj = __v_248; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_249; let __vj = __v_250; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_252: G = (__v_251 * __v_251);
+        if (__v_252 != __v_251) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_251.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) };
+        let __v_253: G = __b2_out.0;
+        let __v_254: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) };
+        let __v_255: G = __b2_out.0;
+        let __v_256: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) };
+        let __v_257: G = __b2_out.0;
+        let __v_258: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record) };
+        let __v_259: G = __b2_out.0;
+        let __v_260: G = __b2_out.1;
+        let __v_261: G = (__v_253 + __v_256);
+        let __v_262: G = (__v_255 + __v_258);
+        let __v_263: G = (__v_257 + __v_260);
+        let __v_264: G = (__v_259 + __v_254);
+        let __u32_sum: u128 = u128::from(((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8) | (__v_11.as_canonical_u64() << 16) | (__v_12.as_canonical_u64() << 24))) + u128::from(((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8) | (__v_27.as_canonical_u64() << 16) | (__v_28.as_canonical_u64() << 24))) + u128::from(((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8) | (__v_83.as_canonical_u64() << 16) | (__v_84.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_265: G = G::from_u8(__u32_bytes[0]);
+        let __v_266: G = G::from_u8(__u32_bytes[1]);
+        let __v_267: G = G::from_u8(__u32_bytes[2]);
+        let __v_268: G = G::from_u8(__u32_bytes[3]);
+        let __v_269: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_265; let __vj = __v_266; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_267; let __vj = __v_268; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_270: G = G::from_u64(1);
+        let __v_271: G = (__v_269 - __v_270);
+        let __v_272: G = G::from_u64(2);
+        let __v_273: G = (__v_269 - __v_272);
+        let __v_274: G = (__v_271 * __v_273);
+        let __v_275: G = (__v_269 * __v_274);
+        let __v_276: G = G::from_u64(0);
+        if (__v_275 != __v_276) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_275.as_canonical_u64(), rhs: __v_276.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) };
+        let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) };
+        let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) };
+        let __v_280: G = if unconstrained { Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record) };
+        let __u32_sum: u128 = u128::from(((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8) | (__v_43.as_canonical_u64() << 16) | (__v_44.as_canonical_u64() << 24))) + u128::from(((__v_279.as_canonical_u64() << 0) | (__v_280.as_canonical_u64() << 8) | (__v_277.as_canonical_u64() << 16) | (__v_278.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_281: G = G::from_u8(__u32_bytes[0]);
+        let __v_282: G = G::from_u8(__u32_bytes[1]);
+        let __v_283: G = G::from_u8(__u32_bytes[2]);
+        let __v_284: G = G::from_u8(__u32_bytes[3]);
+        let __v_285: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_281; let __vj = __v_282; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_283; let __vj = __v_284; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_286: G = (__v_285 * __v_285);
+        if (__v_286 != __v_285) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_286.as_canonical_u64(), rhs: __v_285.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) };
+        let __v_287: G = __b2_out.0;
+        let __v_288: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) };
+        let __v_289: G = __b2_out.0;
+        let __v_290: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) };
+        let __v_291: G = __b2_out.0;
+        let __v_292: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record) };
+        let __v_293: G = __b2_out.0;
+        let __v_294: G = __b2_out.1;
+        let __v_295: G = (__v_289 + __v_292);
+        let __v_296: G = (__v_291 + __v_294);
+        let __v_297: G = (__v_293 + __v_288);
+        let __v_298: G = (__v_287 + __v_290);
+        let __u32_sum: u128 = u128::from(((__v_265.as_canonical_u64() << 0) | (__v_266.as_canonical_u64() << 8) | (__v_267.as_canonical_u64() << 16) | (__v_268.as_canonical_u64() << 24))) + u128::from(((__v_295.as_canonical_u64() << 0) | (__v_296.as_canonical_u64() << 8) | (__v_297.as_canonical_u64() << 16) | (__v_298.as_canonical_u64() << 24))) + u128::from(((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8) | (__v_87.as_canonical_u64() << 16) | (__v_88.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_299: G = G::from_u8(__u32_bytes[0]);
+        let __v_300: G = G::from_u8(__u32_bytes[1]);
+        let __v_301: G = G::from_u8(__u32_bytes[2]);
+        let __v_302: G = G::from_u8(__u32_bytes[3]);
+        let __v_303: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_304: G = G::from_u64(1);
+        let __v_305: G = (__v_303 - __v_304);
+        let __v_306: G = G::from_u64(2);
+        let __v_307: G = (__v_303 - __v_306);
+        let __v_308: G = (__v_305 * __v_307);
+        let __v_309: G = (__v_303 * __v_308);
+        let __v_310: G = G::from_u64(0);
+        if (__v_309 != __v_310) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_310.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) };
+        let __v_312: G = if unconstrained { Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record) };
+        let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) };
+        let __v_314: G = if unconstrained { Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record) };
+        let __u32_sum: u128 = u128::from(((__v_281.as_canonical_u64() << 0) | (__v_282.as_canonical_u64() << 8) | (__v_283.as_canonical_u64() << 16) | (__v_284.as_canonical_u64() << 24))) + u128::from(((__v_312.as_canonical_u64() << 0) | (__v_313.as_canonical_u64() << 8) | (__v_314.as_canonical_u64() << 16) | (__v_311.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_315: G = G::from_u8(__u32_bytes[0]);
+        let __v_316: G = G::from_u8(__u32_bytes[1]);
+        let __v_317: G = G::from_u8(__u32_bytes[2]);
+        let __v_318: G = G::from_u8(__u32_bytes[3]);
+        let __v_319: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_315; let __vj = __v_316; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_320: G = (__v_319 * __v_319);
+        if (__v_320 != __v_319) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_320.as_canonical_u64(), rhs: __v_319.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) };
+        let __v_321: G = __b2_out.0;
+        let __v_322: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) };
+        let __v_323: G = __b2_out.0;
+        let __v_324: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) };
+        let __v_325: G = __b2_out.0;
+        let __v_326: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record) };
+        let __v_327: G = __b2_out.0;
+        let __v_328: G = __b2_out.1;
+        let __v_329: G = (__v_321 + __v_324);
+        let __v_330: G = (__v_323 + __v_326);
+        let __v_331: G = (__v_325 + __v_328);
+        let __v_332: G = (__v_327 + __v_322);
+        let __u32_sum: u128 = u128::from(((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8) | (__v_15.as_canonical_u64() << 16) | (__v_16.as_canonical_u64() << 24))) + u128::from(((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8) | (__v_31.as_canonical_u64() << 16) | (__v_32.as_canonical_u64() << 24))) + u128::from(((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8) | (__v_91.as_canonical_u64() << 16) | (__v_92.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_333: G = G::from_u8(__u32_bytes[0]);
+        let __v_334: G = G::from_u8(__u32_bytes[1]);
+        let __v_335: G = G::from_u8(__u32_bytes[2]);
+        let __v_336: G = G::from_u8(__u32_bytes[3]);
+        let __v_337: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_335; let __vj = __v_336; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_338: G = G::from_u64(1);
+        let __v_339: G = (__v_337 - __v_338);
+        let __v_340: G = G::from_u64(2);
+        let __v_341: G = (__v_337 - __v_340);
+        let __v_342: G = (__v_339 * __v_341);
+        let __v_343: G = (__v_337 * __v_342);
+        let __v_344: G = G::from_u64(0);
+        if (__v_343 != __v_344) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_343.as_canonical_u64(), rhs: __v_344.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) };
+        let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) };
+        let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) };
+        let __v_348: G = if unconstrained { Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record) };
+        let __u32_sum: u128 = u128::from(((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8) | (__v_47.as_canonical_u64() << 16) | (__v_48.as_canonical_u64() << 24))) + u128::from(((__v_347.as_canonical_u64() << 0) | (__v_348.as_canonical_u64() << 8) | (__v_345.as_canonical_u64() << 16) | (__v_346.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_349: G = G::from_u8(__u32_bytes[0]);
+        let __v_350: G = G::from_u8(__u32_bytes[1]);
+        let __v_351: G = G::from_u8(__u32_bytes[2]);
+        let __v_352: G = G::from_u8(__u32_bytes[3]);
+        let __v_353: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_354: G = (__v_353 * __v_353);
+        if (__v_354 != __v_353) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_354.as_canonical_u64(), rhs: __v_353.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) };
+        let __v_355: G = __b2_out.0;
+        let __v_356: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) };
+        let __v_357: G = __b2_out.0;
+        let __v_358: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) };
+        let __v_359: G = __b2_out.0;
+        let __v_360: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record) };
+        let __v_361: G = __b2_out.0;
+        let __v_362: G = __b2_out.1;
+        let __v_363: G = (__v_357 + __v_360);
+        let __v_364: G = (__v_359 + __v_362);
+        let __v_365: G = (__v_361 + __v_356);
+        let __v_366: G = (__v_355 + __v_358);
+        let __u32_sum: u128 = u128::from(((__v_333.as_canonical_u64() << 0) | (__v_334.as_canonical_u64() << 8) | (__v_335.as_canonical_u64() << 16) | (__v_336.as_canonical_u64() << 24))) + u128::from(((__v_363.as_canonical_u64() << 0) | (__v_364.as_canonical_u64() << 8) | (__v_365.as_canonical_u64() << 16) | (__v_366.as_canonical_u64() << 24))) + u128::from(((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8) | (__v_95.as_canonical_u64() << 16) | (__v_96.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_367: G = G::from_u8(__u32_bytes[0]);
+        let __v_368: G = G::from_u8(__u32_bytes[1]);
+        let __v_369: G = G::from_u8(__u32_bytes[2]);
+        let __v_370: G = G::from_u8(__u32_bytes[3]);
+        let __v_371: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_367; let __vj = __v_368; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_369; let __vj = __v_370; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_372: G = G::from_u64(1);
+        let __v_373: G = (__v_371 - __v_372);
+        let __v_374: G = G::from_u64(2);
+        let __v_375: G = (__v_371 - __v_374);
+        let __v_376: G = (__v_373 * __v_375);
+        let __v_377: G = (__v_371 * __v_376);
+        let __v_378: G = G::from_u64(0);
+        if (__v_377 != __v_378) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_377.as_canonical_u64(), rhs: __v_378.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) };
+        let __v_380: G = if unconstrained { Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record) };
+        let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) };
+        let __v_382: G = if unconstrained { Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record) };
+        let __u32_sum: u128 = u128::from(((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8) | (__v_351.as_canonical_u64() << 16) | (__v_352.as_canonical_u64() << 24))) + u128::from(((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8) | (__v_382.as_canonical_u64() << 16) | (__v_379.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_383: G = G::from_u8(__u32_bytes[0]);
+        let __v_384: G = G::from_u8(__u32_bytes[1]);
+        let __v_385: G = G::from_u8(__u32_bytes[2]);
+        let __v_386: G = G::from_u8(__u32_bytes[3]);
+        let __v_387: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_383; let __vj = __v_384; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_385; let __vj = __v_386; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_388: G = (__v_387 * __v_387);
+        if (__v_388 != __v_387) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) };
+        let __v_389: G = __b2_out.0;
+        let __v_390: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) };
+        let __v_391: G = __b2_out.0;
+        let __v_392: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) };
+        let __v_393: G = __b2_out.0;
+        let __v_394: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record) };
+        let __v_395: G = __b2_out.0;
+        let __v_396: G = __b2_out.1;
+        let __v_397: G = (__v_389 + __v_392);
+        let __v_398: G = (__v_391 + __v_394);
+        let __v_399: G = (__v_393 + __v_396);
+        let __v_400: G = (__v_395 + __v_390);
+        let __u32_sum: u128 = u128::from(((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8) | (__v_165.as_canonical_u64() << 16) | (__v_166.as_canonical_u64() << 24))) + u128::from(((__v_261.as_canonical_u64() << 0) | (__v_262.as_canonical_u64() << 8) | (__v_263.as_canonical_u64() << 16) | (__v_264.as_canonical_u64() << 24))) + u128::from(((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8) | (__v_99.as_canonical_u64() << 16) | (__v_100.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_401: G = G::from_u8(__u32_bytes[0]);
+        let __v_402: G = G::from_u8(__u32_bytes[1]);
+        let __v_403: G = G::from_u8(__u32_bytes[2]);
+        let __v_404: G = G::from_u8(__u32_bytes[3]);
+        let __v_405: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_401; let __vj = __v_402; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_403; let __vj = __v_404; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_406: G = G::from_u64(1);
+        let __v_407: G = (__v_405 - __v_406);
+        let __v_408: G = G::from_u64(2);
+        let __v_409: G = (__v_405 - __v_408);
+        let __v_410: G = (__v_407 * __v_409);
+        let __v_411: G = (__v_405 * __v_410);
+        let __v_412: G = G::from_u64(0);
+        if (__v_411 != __v_412) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) };
+        let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) };
+        let __v_415: G = if unconstrained { Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record) };
+        let __v_416: G = if unconstrained { Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record) };
+        let __u32_sum: u128 = u128::from(((__v_315.as_canonical_u64() << 0) | (__v_316.as_canonical_u64() << 8) | (__v_317.as_canonical_u64() << 16) | (__v_318.as_canonical_u64() << 24))) + u128::from(((__v_415.as_canonical_u64() << 0) | (__v_416.as_canonical_u64() << 8) | (__v_413.as_canonical_u64() << 16) | (__v_414.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_417: G = G::from_u8(__u32_bytes[0]);
+        let __v_418: G = G::from_u8(__u32_bytes[1]);
+        let __v_419: G = G::from_u8(__u32_bytes[2]);
+        let __v_420: G = G::from_u8(__u32_bytes[3]);
+        let __v_421: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_417; let __vj = __v_418; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_419; let __vj = __v_420; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_422: G = (__v_421 * __v_421);
+        if (__v_422 != __v_421) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_422.as_canonical_u64(), rhs: __v_421.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) };
+        let __v_423: G = __b2_out.0;
+        let __v_424: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) };
+        let __v_425: G = __b2_out.0;
+        let __v_426: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) };
+        let __v_427: G = __b2_out.0;
+        let __v_428: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record) };
+        let __v_429: G = __b2_out.0;
+        let __v_430: G = __b2_out.1;
+        let __v_431: G = (__v_425 + __v_428);
+        let __v_432: G = (__v_427 + __v_430);
+        let __v_433: G = (__v_429 + __v_424);
+        let __v_434: G = (__v_423 + __v_426);
+        let __u32_sum: u128 = u128::from(((__v_401.as_canonical_u64() << 0) | (__v_402.as_canonical_u64() << 8) | (__v_403.as_canonical_u64() << 16) | (__v_404.as_canonical_u64() << 24))) + u128::from(((__v_431.as_canonical_u64() << 0) | (__v_432.as_canonical_u64() << 8) | (__v_433.as_canonical_u64() << 16) | (__v_434.as_canonical_u64() << 24))) + u128::from(((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8) | (__v_103.as_canonical_u64() << 16) | (__v_104.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_435: G = G::from_u8(__u32_bytes[0]);
+        let __v_436: G = G::from_u8(__u32_bytes[1]);
+        let __v_437: G = G::from_u8(__u32_bytes[2]);
+        let __v_438: G = G::from_u8(__u32_bytes[3]);
+        let __v_439: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_435; let __vj = __v_436; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_437; let __vj = __v_438; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_440: G = G::from_u64(1);
+        let __v_441: G = (__v_439 - __v_440);
+        let __v_442: G = G::from_u64(2);
+        let __v_443: G = (__v_439 - __v_442);
+        let __v_444: G = (__v_441 * __v_443);
+        let __v_445: G = (__v_439 * __v_444);
+        let __v_446: G = G::from_u64(0);
+        if (__v_445 != __v_446) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_445.as_canonical_u64(), rhs: __v_446.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) };
+        let __v_448: G = if unconstrained { Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record) };
+        let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) };
+        let __v_450: G = if unconstrained { Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record) };
+        let __u32_sum: u128 = u128::from(((__v_417.as_canonical_u64() << 0) | (__v_418.as_canonical_u64() << 8) | (__v_419.as_canonical_u64() << 16) | (__v_420.as_canonical_u64() << 24))) + u128::from(((__v_448.as_canonical_u64() << 0) | (__v_449.as_canonical_u64() << 8) | (__v_450.as_canonical_u64() << 16) | (__v_447.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_451: G = G::from_u8(__u32_bytes[0]);
+        let __v_452: G = G::from_u8(__u32_bytes[1]);
+        let __v_453: G = G::from_u8(__u32_bytes[2]);
+        let __v_454: G = G::from_u8(__u32_bytes[3]);
+        let __v_455: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_451; let __vj = __v_452; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_453; let __vj = __v_454; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_456: G = (__v_455 * __v_455);
+        if (__v_456 != __v_455) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) };
+        let __v_457: G = __b2_out.0;
+        let __v_458: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) };
+        let __v_459: G = __b2_out.0;
+        let __v_460: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) };
+        let __v_461: G = __b2_out.0;
+        let __v_462: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record) };
+        let __v_463: G = __b2_out.0;
+        let __v_464: G = __b2_out.1;
+        let __v_465: G = (__v_457 + __v_460);
+        let __v_466: G = (__v_459 + __v_462);
+        let __v_467: G = (__v_461 + __v_464);
+        let __v_468: G = (__v_463 + __v_458);
+        let __u32_sum: u128 = u128::from(((__v_231.as_canonical_u64() << 0) | (__v_232.as_canonical_u64() << 8) | (__v_233.as_canonical_u64() << 16) | (__v_234.as_canonical_u64() << 24))) + u128::from(((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8) | (__v_331.as_canonical_u64() << 16) | (__v_332.as_canonical_u64() << 24))) + u128::from(((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8) | (__v_107.as_canonical_u64() << 16) | (__v_108.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_469: G = G::from_u8(__u32_bytes[0]);
+        let __v_470: G = G::from_u8(__u32_bytes[1]);
+        let __v_471: G = G::from_u8(__u32_bytes[2]);
+        let __v_472: G = G::from_u8(__u32_bytes[3]);
+        let __v_473: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_469; let __vj = __v_470; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_471; let __vj = __v_472; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_474: G = G::from_u64(1);
+        let __v_475: G = (__v_473 - __v_474);
+        let __v_476: G = G::from_u64(2);
+        let __v_477: G = (__v_473 - __v_476);
+        let __v_478: G = (__v_475 * __v_477);
+        let __v_479: G = (__v_473 * __v_478);
+        let __v_480: G = G::from_u64(0);
+        if (__v_479 != __v_480) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_480.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) };
+        let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) };
+        let __v_483: G = if unconstrained { Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record) };
+        let __v_484: G = if unconstrained { Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record) };
+        let __u32_sum: u128 = u128::from(((__v_383.as_canonical_u64() << 0) | (__v_384.as_canonical_u64() << 8) | (__v_385.as_canonical_u64() << 16) | (__v_386.as_canonical_u64() << 24))) + u128::from(((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8) | (__v_481.as_canonical_u64() << 16) | (__v_482.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_485: G = G::from_u8(__u32_bytes[0]);
+        let __v_486: G = G::from_u8(__u32_bytes[1]);
+        let __v_487: G = G::from_u8(__u32_bytes[2]);
+        let __v_488: G = G::from_u8(__u32_bytes[3]);
+        let __v_489: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_490: G = (__v_489 * __v_489);
+        if (__v_490 != __v_489) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) };
+        let __v_491: G = __b2_out.0;
+        let __v_492: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) };
+        let __v_493: G = __b2_out.0;
+        let __v_494: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) };
+        let __v_495: G = __b2_out.0;
+        let __v_496: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record) };
+        let __v_497: G = __b2_out.0;
+        let __v_498: G = __b2_out.1;
+        let __v_499: G = (__v_493 + __v_496);
+        let __v_500: G = (__v_495 + __v_498);
+        let __v_501: G = (__v_497 + __v_492);
+        let __v_502: G = (__v_491 + __v_494);
+        let __u32_sum: u128 = u128::from(((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8) | (__v_471.as_canonical_u64() << 16) | (__v_472.as_canonical_u64() << 24))) + u128::from(((__v_499.as_canonical_u64() << 0) | (__v_500.as_canonical_u64() << 8) | (__v_501.as_canonical_u64() << 16) | (__v_502.as_canonical_u64() << 24))) + u128::from(((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8) | (__v_111.as_canonical_u64() << 16) | (__v_112.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_503: G = G::from_u8(__u32_bytes[0]);
+        let __v_504: G = G::from_u8(__u32_bytes[1]);
+        let __v_505: G = G::from_u8(__u32_bytes[2]);
+        let __v_506: G = G::from_u8(__u32_bytes[3]);
+        let __v_507: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_508: G = G::from_u64(1);
+        let __v_509: G = (__v_507 - __v_508);
+        let __v_510: G = G::from_u64(2);
+        let __v_511: G = (__v_507 - __v_510);
+        let __v_512: G = (__v_509 * __v_511);
+        let __v_513: G = (__v_507 * __v_512);
+        let __v_514: G = G::from_u64(0);
+        if (__v_513 != __v_514) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) };
+        let __v_516: G = if unconstrained { Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record) };
+        let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) };
+        let __v_518: G = if unconstrained { Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record) };
+        let __u32_sum: u128 = u128::from(((__v_485.as_canonical_u64() << 0) | (__v_486.as_canonical_u64() << 8) | (__v_487.as_canonical_u64() << 16) | (__v_488.as_canonical_u64() << 24))) + u128::from(((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8) | (__v_518.as_canonical_u64() << 16) | (__v_515.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_519: G = G::from_u8(__u32_bytes[0]);
+        let __v_520: G = G::from_u8(__u32_bytes[1]);
+        let __v_521: G = G::from_u8(__u32_bytes[2]);
+        let __v_522: G = G::from_u8(__u32_bytes[3]);
+        let __v_523: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_521; let __vj = __v_522; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_524: G = (__v_523 * __v_523);
+        if (__v_524 != __v_523) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_524.as_canonical_u64(), rhs: __v_523.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) };
+        let __v_525: G = __b2_out.0;
+        let __v_526: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) };
+        let __v_527: G = __b2_out.0;
+        let __v_528: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) };
+        let __v_529: G = __b2_out.0;
+        let __v_530: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record) };
+        let __v_531: G = __b2_out.0;
+        let __v_532: G = __b2_out.1;
+        let __v_533: G = (__v_525 + __v_528);
+        let __v_534: G = (__v_527 + __v_530);
+        let __v_535: G = (__v_529 + __v_532);
+        let __v_536: G = (__v_531 + __v_526);
+        let __u32_sum: u128 = u128::from(((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8) | (__v_301.as_canonical_u64() << 16) | (__v_302.as_canonical_u64() << 24))) + u128::from(((__v_397.as_canonical_u64() << 0) | (__v_398.as_canonical_u64() << 8) | (__v_399.as_canonical_u64() << 16) | (__v_400.as_canonical_u64() << 24))) + u128::from(((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8) | (__v_115.as_canonical_u64() << 16) | (__v_116.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_537: G = G::from_u8(__u32_bytes[0]);
+        let __v_538: G = G::from_u8(__u32_bytes[1]);
+        let __v_539: G = G::from_u8(__u32_bytes[2]);
+        let __v_540: G = G::from_u8(__u32_bytes[3]);
+        let __v_541: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_539; let __vj = __v_540; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_542: G = G::from_u64(1);
+        let __v_543: G = (__v_541 - __v_542);
+        let __v_544: G = G::from_u64(2);
+        let __v_545: G = (__v_541 - __v_544);
+        let __v_546: G = (__v_543 * __v_545);
+        let __v_547: G = (__v_541 * __v_546);
+        let __v_548: G = G::from_u64(0);
+        if (__v_547 != __v_548) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_547.as_canonical_u64(), rhs: __v_548.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) };
+        let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) };
+        let __v_551: G = if unconstrained { Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record) };
+        let __v_552: G = if unconstrained { Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record) };
+        let __u32_sum: u128 = u128::from(((__v_179.as_canonical_u64() << 0) | (__v_180.as_canonical_u64() << 8) | (__v_181.as_canonical_u64() << 16) | (__v_182.as_canonical_u64() << 24))) + u128::from(((__v_551.as_canonical_u64() << 0) | (__v_552.as_canonical_u64() << 8) | (__v_549.as_canonical_u64() << 16) | (__v_550.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_553: G = G::from_u8(__u32_bytes[0]);
+        let __v_554: G = G::from_u8(__u32_bytes[1]);
+        let __v_555: G = G::from_u8(__u32_bytes[2]);
+        let __v_556: G = G::from_u8(__u32_bytes[3]);
+        let __v_557: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_553; let __vj = __v_554; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_555; let __vj = __v_556; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_558: G = (__v_557 * __v_557);
+        if (__v_558 != __v_557) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_558.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
         }
-      },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            let __v_10: G = __loaded[2];
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_11: G = __loaded[0];
-                let __v_12: G = __loaded[1];
-                let __v_13: G = __loaded[2];
-                match __v_11.as_canonical_u64() {
-                  0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_14: G = __loaded[0];
-                    let __v_15: G = __loaded[1];
-                    let __v_16: G = __loaded[2];
-                    match __v_14.as_canonical_u64() {
-                      0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_17: G = __loaded[0];
-                        let __v_18: G = __loaded[1];
-                        let __v_19: G = __loaded[2];
-                        match __v_17.as_canonical_u64() {
-                          0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_20: G = __loaded[0];
-                            let __v_21: G = __loaded[1];
-                            let __v_22: G = __loaded[2];
-                            match __v_20.as_canonical_u64() {
-                              0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                let __v_23: G = __loaded[0];
-                                let __v_24: G = __loaded[1];
-                                let __v_25: G = __loaded[2];
-                                match __v_23.as_canonical_u64() {
-                                  0u64 => {
-                                    let __ret: [G; OUT_150] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25];
-                                    if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                    return Ok(__ret);
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) };
+        let __v_559: G = __b2_out.0;
+        let __v_560: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) };
+        let __v_561: G = __b2_out.0;
+        let __v_562: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) };
+        let __v_563: G = __b2_out.0;
+        let __v_564: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record) };
+        let __v_565: G = __b2_out.0;
+        let __v_566: G = __b2_out.1;
+        let __v_567: G = (__v_561 + __v_564);
+        let __v_568: G = (__v_563 + __v_566);
+        let __v_569: G = (__v_565 + __v_560);
+        let __v_570: G = (__v_559 + __v_562);
+        let __u32_sum: u128 = u128::from(((__v_537.as_canonical_u64() << 0) | (__v_538.as_canonical_u64() << 8) | (__v_539.as_canonical_u64() << 16) | (__v_540.as_canonical_u64() << 24))) + u128::from(((__v_567.as_canonical_u64() << 0) | (__v_568.as_canonical_u64() << 8) | (__v_569.as_canonical_u64() << 16) | (__v_570.as_canonical_u64() << 24))) + u128::from(((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8) | (__v_119.as_canonical_u64() << 16) | (__v_120.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_571: G = G::from_u8(__u32_bytes[0]);
+        let __v_572: G = G::from_u8(__u32_bytes[1]);
+        let __v_573: G = G::from_u8(__u32_bytes[2]);
+        let __v_574: G = G::from_u8(__u32_bytes[3]);
+        let __v_575: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_571; let __vj = __v_572; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_573; let __vj = __v_574; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_576: G = G::from_u64(1);
+        let __v_577: G = (__v_575 - __v_576);
+        let __v_578: G = G::from_u64(2);
+        let __v_579: G = (__v_575 - __v_578);
+        let __v_580: G = (__v_577 * __v_579);
+        let __v_581: G = (__v_575 * __v_580);
+        let __v_582: G = G::from_u64(0);
+        if (__v_581 != __v_582) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_581.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
         }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) };
+        let __v_584: G = if unconstrained { Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record) };
+        let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) };
+        let __v_586: G = if unconstrained { Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record) };
+        let __u32_sum: u128 = u128::from(((__v_553.as_canonical_u64() << 0) | (__v_554.as_canonical_u64() << 8) | (__v_555.as_canonical_u64() << 16) | (__v_556.as_canonical_u64() << 24))) + u128::from(((__v_584.as_canonical_u64() << 0) | (__v_585.as_canonical_u64() << 8) | (__v_586.as_canonical_u64() << 16) | (__v_583.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_587: G = G::from_u8(__u32_bytes[0]);
+        let __v_588: G = G::from_u8(__u32_bytes[1]);
+        let __v_589: G = G::from_u8(__u32_bytes[2]);
+        let __v_590: G = G::from_u8(__u32_bytes[3]);
+        let __v_591: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_587; let __vj = __v_588; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_589; let __vj = __v_590; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_592: G = (__v_591 * __v_591);
+        if (__v_592 != __v_591) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_592.as_canonical_u64(), rhs: __v_591.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) };
+        let __v_593: G = __b2_out.0;
+        let __v_594: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) };
+        let __v_595: G = __b2_out.0;
+        let __v_596: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) };
+        let __v_597: G = __b2_out.0;
+        let __v_598: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record) };
+        let __v_599: G = __b2_out.0;
+        let __v_600: G = __b2_out.1;
+        let __v_601: G = (__v_593 + __v_596);
+        let __v_602: G = (__v_595 + __v_598);
+        let __v_603: G = (__v_597 + __v_600);
+        let __v_604: G = (__v_599 + __v_594);
+        let __u32_sum: u128 = u128::from(((__v_367.as_canonical_u64() << 0) | (__v_368.as_canonical_u64() << 8) | (__v_369.as_canonical_u64() << 16) | (__v_370.as_canonical_u64() << 24))) + u128::from(((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8) | (__v_195.as_canonical_u64() << 16) | (__v_196.as_canonical_u64() << 24))) + u128::from(((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8) | (__v_123.as_canonical_u64() << 16) | (__v_124.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_605: G = G::from_u8(__u32_bytes[0]);
+        let __v_606: G = G::from_u8(__u32_bytes[1]);
+        let __v_607: G = G::from_u8(__u32_bytes[2]);
+        let __v_608: G = G::from_u8(__u32_bytes[3]);
+        let __v_609: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_605; let __vj = __v_606; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_607; let __vj = __v_608; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_610: G = G::from_u64(1);
+        let __v_611: G = (__v_609 - __v_610);
+        let __v_612: G = G::from_u64(2);
+        let __v_613: G = (__v_609 - __v_612);
+        let __v_614: G = (__v_611 * __v_613);
+        let __v_615: G = (__v_609 * __v_614);
+        let __v_616: G = G::from_u64(0);
+        if (__v_615 != __v_616) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_616.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) };
+        let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) };
+        let __v_619: G = if unconstrained { Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record) };
+        let __v_620: G = if unconstrained { Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record) };
+        let __u32_sum: u128 = u128::from(((__v_247.as_canonical_u64() << 0) | (__v_248.as_canonical_u64() << 8) | (__v_249.as_canonical_u64() << 16) | (__v_250.as_canonical_u64() << 24))) + u128::from(((__v_619.as_canonical_u64() << 0) | (__v_620.as_canonical_u64() << 8) | (__v_617.as_canonical_u64() << 16) | (__v_618.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_621: G = G::from_u8(__u32_bytes[0]);
+        let __v_622: G = G::from_u8(__u32_bytes[1]);
+        let __v_623: G = G::from_u8(__u32_bytes[2]);
+        let __v_624: G = G::from_u8(__u32_bytes[3]);
+        let __v_625: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_621; let __vj = __v_622; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_623; let __vj = __v_624; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_626: G = (__v_625 * __v_625);
+        if (__v_626 != __v_625) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_626.as_canonical_u64(), rhs: __v_625.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) };
+        let __v_627: G = __b2_out.0;
+        let __v_628: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) };
+        let __v_629: G = __b2_out.0;
+        let __v_630: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) };
+        let __v_631: G = __b2_out.0;
+        let __v_632: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record) };
+        let __v_633: G = __b2_out.0;
+        let __v_634: G = __b2_out.1;
+        let __v_635: G = (__v_629 + __v_632);
+        let __v_636: G = (__v_631 + __v_634);
+        let __v_637: G = (__v_633 + __v_628);
+        let __v_638: G = (__v_627 + __v_630);
+        let __u32_sum: u128 = u128::from(((__v_605.as_canonical_u64() << 0) | (__v_606.as_canonical_u64() << 8) | (__v_607.as_canonical_u64() << 16) | (__v_608.as_canonical_u64() << 24))) + u128::from(((__v_635.as_canonical_u64() << 0) | (__v_636.as_canonical_u64() << 8) | (__v_637.as_canonical_u64() << 16) | (__v_638.as_canonical_u64() << 24))) + u128::from(((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8) | (__v_127.as_canonical_u64() << 16) | (__v_128.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_639: G = G::from_u8(__u32_bytes[0]);
+        let __v_640: G = G::from_u8(__u32_bytes[1]);
+        let __v_641: G = G::from_u8(__u32_bytes[2]);
+        let __v_642: G = G::from_u8(__u32_bytes[3]);
+        let __v_643: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_639; let __vj = __v_640; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_641; let __vj = __v_642; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_644: G = G::from_u64(1);
+        let __v_645: G = (__v_643 - __v_644);
+        let __v_646: G = G::from_u64(2);
+        let __v_647: G = (__v_643 - __v_646);
+        let __v_648: G = (__v_645 * __v_647);
+        let __v_649: G = (__v_643 * __v_648);
+        let __v_650: G = G::from_u64(0);
+        if (__v_649 != __v_650) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) };
+        let __v_652: G = if unconstrained { Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record) };
+        let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) };
+        let __v_654: G = if unconstrained { Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record) };
+        let __u32_sum: u128 = u128::from(((__v_621.as_canonical_u64() << 0) | (__v_622.as_canonical_u64() << 8) | (__v_623.as_canonical_u64() << 16) | (__v_624.as_canonical_u64() << 24))) + u128::from(((__v_652.as_canonical_u64() << 0) | (__v_653.as_canonical_u64() << 8) | (__v_654.as_canonical_u64() << 16) | (__v_651.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_655: G = G::from_u8(__u32_bytes[0]);
+        let __v_656: G = G::from_u8(__u32_bytes[1]);
+        let __v_657: G = G::from_u8(__u32_bytes[2]);
+        let __v_658: G = G::from_u8(__u32_bytes[3]);
+        let __v_659: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_655; let __vj = __v_656; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_657; let __vj = __v_658; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_660: G = (__v_659 * __v_659);
+        if (__v_660 != __v_659) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_660.as_canonical_u64(), rhs: __v_659.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) };
+        let __v_661: G = __b2_out.0;
+        let __v_662: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) };
+        let __v_663: G = __b2_out.0;
+        let __v_664: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) };
+        let __v_665: G = __b2_out.0;
+        let __v_666: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record) };
+        let __v_667: G = __b2_out.0;
+        let __v_668: G = __b2_out.1;
+        let __v_669: G = (__v_661 + __v_664);
+        let __v_670: G = (__v_663 + __v_666);
+        let __v_671: G = (__v_665 + __v_668);
+        let __v_672: G = (__v_667 + __v_662);
+        let __v_673: G = G::from_u64(1);
+        let __v_674: G = (__v_0 + __v_673);
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __v_675: G = __r_arr[0];
+        let __v_676: G = __r_arr[1];
+        let __v_677: G = __r_arr[2];
+        let __v_678: G = __r_arr[3];
+        let __v_679: G = __r_arr[4];
+        let __v_680: G = __r_arr[5];
+        let __v_681: G = __r_arr[6];
+        let __v_682: G = __r_arr[7];
+        let __v_683: G = __r_arr[8];
+        let __v_684: G = __r_arr[9];
+        let __v_685: G = __r_arr[10];
+        let __v_686: G = __r_arr[11];
+        let __v_687: G = __r_arr[12];
+        let __v_688: G = __r_arr[13];
+        let __v_689: G = __r_arr[14];
+        let __v_690: G = __r_arr[15];
+        let __v_691: G = __r_arr[16];
+        let __v_692: G = __r_arr[17];
+        let __v_693: G = __r_arr[18];
+        let __v_694: G = __r_arr[19];
+        let __v_695: G = __r_arr[20];
+        let __v_696: G = __r_arr[21];
+        let __v_697: G = __r_arr[22];
+        let __v_698: G = __r_arr[23];
+        let __v_699: G = __r_arr[24];
+        let __v_700: G = __r_arr[25];
+        let __v_701: G = __r_arr[26];
+        let __v_702: G = __r_arr[27];
+        let __v_703: G = __r_arr[28];
+        let __v_704: G = __r_arr[29];
+        let __v_705: G = __r_arr[30];
+        let __v_706: G = __r_arr[31];
+        let __ret: [G; OUT_83] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706];
+        if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_151: usize = 2;
-const IN_151: usize = 2;
-const OUT_151: usize = 10;
-fn aiur_fn_151(
-  inp: [G; IN_151],
+const INPUT_SIZE_84: usize = 1;
+const IN_84: usize = 1;
+const OUT_84: usize = 2;
+fn aiur_fn_84(
+  inp: [G; IN_84],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_151], ExecError> {
+) -> Result<[G; OUT_84], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    let __v_4: G = __r_arr[2];
-    let __v_5: G = __r_arr[3];
-    let __v_6: G = __r_arr[4];
-    let __v_7: G = __r_arr[5];
-    let __v_8: G = __r_arr[6];
-    let __v_9: G = __r_arr[7];
-    let __v_10: G = __r_arr[8];
-    let __v_11: G = __r_arr[9];
-    let __v_12: G = G::from_u64(1020);
-    let __v_13: G = (__v_9 - __v_12);
-    let __v_14: G = (__v_8 + __v_13);
-    let __v_15: G = (__v_7 + __v_14);
-    let __v_16: G = (__v_6 + __v_15);
-    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
-    let __v_18: G = (__v_4 + __v_5);
-    let __v_19: G = (__v_3 + __v_18);
-    let __v_20: G = (__v_2 + __v_19);
-    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
-    let __v_22: G = G::from_u64(1);
-    let __v_23: G = G::from_u64(1);
-    let __v_24: G = (__v_23 - __v_21);
-    let __v_25: G = (__v_17 * __v_24);
-    let __v_26: G = (__v_22 - __v_25);
-    match __v_26.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_151] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_84] = [__v_2, __v_3];
+        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = __r_arr[1];
-        let __v_29: G = __r_arr[2];
-        let __v_30: G = __r_arr[3];
-        let __v_31: G = __r_arr[4];
-        let __v_32: G = __r_arr[5];
-        let __v_33: G = __r_arr[6];
-        let __v_34: G = __r_arr[7];
-        let __v_35: G = __r_arr[8];
-        let __v_36: G = __r_arr[9];
-        let __ret: [G; OUT_151] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_152: usize = 2;
-const IN_152: usize = 2;
-const OUT_152: usize = 18;
-fn aiur_fn_152(
-  inp: [G; IN_152],
+const INPUT_SIZE_85: usize = 1;
+const IN_85: usize = 1;
+const OUT_85: usize = 2;
+fn aiur_fn_85(
+  inp: [G; IN_85],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_85], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __ret: [G; OUT_85] = [__v_1, __v_2];
+    if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_86: usize = 1;
+const IN_86: usize = 1;
+const OUT_86: usize = 2;
+fn aiur_fn_86(
+  inp: [G; IN_86],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_86], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(256);
+    let __v_6: G = (__v_5 * __v_3);
+    let __v_7: G = (__v_1 + __v_6);
+    let __ret: [G; OUT_86] = [__v_7, __v_4];
+    if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_87: usize = 1;
+const IN_87: usize = 1;
+const OUT_87: usize = 10;
+fn aiur_fn_87(
+  inp: [G; IN_87],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_87], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(256);
+    let __v_6: G = (__v_5 * __v_3);
+    let __v_7: G = (__v_1 + __v_6);
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __ret: [G; OUT_87] = [__v_7, __v_1, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4];
+    if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_88: usize = 1;
+const IN_88: usize = 1;
+const OUT_88: usize = 10;
+fn aiur_fn_88(
+  inp: [G; IN_88],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_88], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __v_9: G = G::from_u64(256);
+    let __v_10: G = (__v_9 * __v_3);
+    let __v_11: G = G::from_u64(65536);
+    let __v_12: G = (__v_11 * __v_5);
+    let __v_13: G = G::from_u64(16777216);
+    let __v_14: G = (__v_13 * __v_7);
+    let __v_15: G = (__v_12 + __v_14);
+    let __v_16: G = (__v_10 + __v_15);
+    let __v_17: G = (__v_1 + __v_16);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(0);
+    let __ret: [G; OUT_88] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_19, __v_20, __v_21, __v_8];
+    if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_89: usize = 1;
+const IN_89: usize = 1;
+const OUT_89: usize = 9;
+fn aiur_fn_89(
+  inp: [G; IN_89],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_89], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __ret: [G; OUT_89] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
+    if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_90: usize = 1;
+const IN_90: usize = 1;
+const OUT_90: usize = 2;
+fn aiur_fn_90(
+  inp: [G; IN_90],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_90], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = G::from_u64(256);
+    let __v_11: G = (__v_10 * __v_2);
+    let __v_12: G = G::from_u64(65536);
+    let __v_13: G = (__v_12 * __v_3);
+    let __v_14: G = G::from_u64(16777216);
+    let __v_15: G = (__v_14 * __v_4);
+    let __v_16: G = G::from_u64(4294967296);
+    let __v_17: G = (__v_16 * __v_5);
+    let __v_18: G = G::from_u64(1099511627776);
+    let __v_19: G = (__v_18 * __v_6);
+    let __v_20: G = G::from_u64(281474976710656);
+    let __v_21: G = (__v_20 * __v_7);
+    let __v_22: G = G::from_u64(72057594037927936);
+    let __v_23: G = (__v_22 * __v_8);
+    let __v_24: G = (__v_21 + __v_23);
+    let __v_25: G = (__v_19 + __v_24);
+    let __v_26: G = (__v_17 + __v_25);
+    let __v_27: G = (__v_15 + __v_26);
+    let __v_28: G = (__v_13 + __v_27);
+    let __v_29: G = (__v_11 + __v_28);
+    let __v_30: G = (__v_1 + __v_29);
+    let __ret: [G; OUT_90] = [__v_30, __v_9];
+    if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_91: usize = 2;
+const IN_91: usize = 2;
+const OUT_91: usize = 2;
+fn aiur_fn_91(
+  inp: [G; IN_91],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_152], ExecError> {
+) -> Result<[G; OUT_91], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    let __v_4: G = __r_arr[2];
-    let __v_5: G = __r_arr[3];
-    let __v_6: G = __r_arr[4];
-    let __v_7: G = __r_arr[5];
-    let __v_8: G = __r_arr[6];
-    let __v_9: G = __r_arr[7];
-    let __v_10: G = __r_arr[8];
-    let __v_11: G = __r_arr[9];
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __v_13: G = __r_arr[1];
-    let __v_14: G = __r_arr[2];
-    let __v_15: G = __r_arr[3];
-    let __v_16: G = __r_arr[4];
-    let __v_17: G = __r_arr[5];
-    let __v_18: G = __r_arr[6];
-    let __v_19: G = __r_arr[7];
-    let __v_20: G = __r_arr[8];
-    let __v_21: G = __r_arr[9];
-    let __ret: [G; OUT_152] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-    if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_91] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(0);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_13, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(0);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_13, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(2);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_13, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(3);
+            let __v_10: G = G::from_u64(3);
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_11, __v_7];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(4);
+            let __v_10: G = G::from_u64(4);
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_11, __v_7];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          5u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(5);
+            let __v_10: G = G::from_u64(5);
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_11, __v_7];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          6u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(6);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_15, __v_11];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          7u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(7);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_15, __v_11];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          8u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(8);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_15, __v_11];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          9u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(9);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_13, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          10u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_14, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          11u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_14, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          12u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_14, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          13u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_14, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          14u64 => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(2);
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_14, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(2);
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_14, __v_9];
+            if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_153: usize = 2;
-const IN_153: usize = 2;
-const OUT_153: usize = 1;
-fn aiur_fn_153(
-  inp: [G; IN_153],
+const INPUT_SIZE_92: usize = 2;
+const IN_92: usize = 2;
+const OUT_92: usize = 2;
+fn aiur_fn_92(
+  inp: [G; IN_92],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_153], ExecError> {
+) -> Result<[G; OUT_92], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14437,955 +8687,6954 @@ fn aiur_fn_153(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_153] = [__v_4];
-        if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_92] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_2: G = __loaded[0];
-        let __v_3: G = __loaded[1];
-        let __v_4: G = __loaded[2];
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __v_5: G = G::from_u64(0);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_153] = [__v_9];
-            if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
-        }
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_92] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_154: usize = 3;
-const IN_154: usize = 3;
-const OUT_154: usize = 3;
-fn aiur_fn_154(
-  inp: [G; IN_154],
+const INPUT_SIZE_93: usize = 1;
+const IN_93: usize = 1;
+const OUT_93: usize = 3;
+fn aiur_fn_93(
+  inp: [G; IN_93],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_154], ExecError> {
+) -> Result<[G; OUT_93], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __v_5: G = __r_arr[2];
-    let __v_6: G = __r_arr[3];
-    let __v_7: G = __r_arr[4];
-    let __v_8: G = __r_arr[5];
-    let __v_9: G = __r_arr[6];
-    let __v_10: G = __r_arr[7];
-    let __v_11: G = __r_arr[8];
-    let __v_12: G = __r_arr[9];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) };
-    let __v_13: G = __b1_out[0];
-    let __v_14: G = __b1_out[1];
-    let __v_15: G = __b1_out[2];
-    let __v_16: G = __b1_out[3];
-    let __v_17: G = __b1_out[4];
-    let __v_18: G = __b1_out[5];
-    let __v_19: G = __b1_out[6];
-    let __v_20: G = __b1_out[7];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) };
-    let __v_21: G = __b1_out[0];
-    let __v_22: G = __b1_out[1];
-    let __v_23: G = __b1_out[2];
-    let __v_24: G = __b1_out[3];
-    let __v_25: G = __b1_out[4];
-    let __v_26: G = __b1_out[5];
-    let __v_27: G = __b1_out[6];
-    let __v_28: G = __b1_out[7];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record) };
-    let __v_29: G = __b1_out[0];
-    let __v_30: G = __b1_out[1];
-    let __v_31: G = __b1_out[2];
-    let __v_32: G = __b1_out[3];
-    let __v_33: G = __b1_out[4];
-    let __v_34: G = __b1_out[5];
-    let __v_35: G = __b1_out[6];
-    let __v_36: G = __b1_out[7];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record) };
-    let __v_37: G = __b1_out[0];
-    let __v_38: G = __b1_out[1];
-    let __v_39: G = __b1_out[2];
-    let __v_40: G = __b1_out[3];
-    let __v_41: G = __b1_out[4];
-    let __v_42: G = __b1_out[5];
-    let __v_43: G = __b1_out[6];
-    let __v_44: G = __b1_out[7];
-    let __v_45: G = G::from_u64(1);
-    let __v_46: G = G::from_u64(1);
-    let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_48: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_49: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_50: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
-    let __v_52: G = __r_arr[0];
-    let __ret: [G; OUT_154] = [__v_52, __v_11, __v_12];
-    if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_155: usize = 9;
-const IN_155: usize = 9;
-const OUT_155: usize = 1;
-fn aiur_fn_155(
-  inp: [G; IN_155],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_155], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __ret: [G; OUT_155] = [__v_13];
-    if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_156: usize = 2;
-const IN_156: usize = 2;
-const OUT_156: usize = 1;
-fn aiur_fn_156(
-  inp: [G; IN_156],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_156], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_156] = [__v_6];
-    if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_157: usize = 1;
-const IN_157: usize = 1;
-const OUT_157: usize = 1;
-fn aiur_fn_157(
-  inp: [G; IN_157],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_157], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __v_2: G = G::from_u64(109);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(117);
-    let __v_5: G = G::from_u64(0);
-    let __v_6: G = G::from_u64(108);
-    let __v_7: G = G::from_u64(0);
-    let __v_8: G = G::from_u64(116);
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(105);
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(45);
-    let __v_13: G = G::from_u64(0);
-    let __v_14: G = G::from_u64(115);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(116);
-    let __v_17: G = G::from_u64(0);
-    let __v_18: G = G::from_u64(97);
-    let __v_19: G = G::from_u64(0);
-    let __v_20: G = G::from_u64(114);
-    let __v_21: G = G::from_u64(0);
-    let __v_22: G = G::from_u64(107);
-    let __v_23: G = G::from_u64(0);
-    let __v_24: G = G::from_u64(47);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = G::from_u64(118);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(48);
-    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_157] = [__v_42];
-    if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_93] = [__v_1, __v_5, __v_6];
+    if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_158: usize = 2;
-const IN_158: usize = 2;
-const OUT_158: usize = 1;
-fn aiur_fn_158(
-  inp: [G; IN_158],
+const INPUT_SIZE_94: usize = 2;
+const IN_94: usize = 2;
+const OUT_94: usize = 2;
+fn aiur_fn_94(
+  inp: [G; IN_94],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_158], ExecError> {
+) -> Result<[G; OUT_94], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_158] = [__v_1];
-        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_94] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_158] = [__v_13];
-        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+      _ => {
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_1 - __v_8);
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_94] = [__v_13, __v_11];
+        if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_159: usize = 2;
-const IN_159: usize = 2;
-const OUT_159: usize = 1;
-fn aiur_fn_159(
-  inp: [G; IN_159],
+const INPUT_SIZE_95: usize = 3;
+const IN_95: usize = 3;
+const OUT_95: usize = 1;
+fn aiur_fn_95(
+  inp: [G; IN_95],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_159], ExecError> {
+) -> Result<[G; OUT_95], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_159] = [__v_4];
-        if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __ret: [G; OUT_159] = [__v_1];
-        if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_95] = [__v_3];
+        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_3: G = G::from_u64(1);
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_0 - __v_4);
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_2 - __v_6);
+            let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_5, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = (__v_3 + __v_8);
+            let __ret: [G; OUT_95] = [__v_9];
+            if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_3: G = G::from_u64(1);
+            let __v_4: G = (__v_0 - __v_3);
+            let __v_5: G = G::from_u64(1);
+            let __v_6: G = (__v_1 - __v_5);
+            let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_95] = [__v_7];
+            if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_160: usize = 9;
-const IN_160: usize = 9;
-const OUT_160: usize = 9;
-fn aiur_fn_160(
-  inp: [G; IN_160],
+const INPUT_SIZE_96: usize = 1;
+const IN_96: usize = 1;
+const OUT_96: usize = 63;
+fn aiur_fn_96(
+  inp: [G; IN_96],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_160], ExecError> {
+) -> Result<[G; OUT_96], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(109);
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = G::from_u64(117);
-    let __v_18: G = G::from_u64(0);
-    let __v_19: G = G::from_u64(108);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = G::from_u64(116);
-    let __v_22: G = G::from_u64(0);
-    let __v_23: G = G::from_u64(105);
-    let __v_24: G = G::from_u64(0);
-    let __v_25: G = G::from_u64(45);
-    let __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(115);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(116);
-    let __v_30: G = G::from_u64(0);
-    let __v_31: G = G::from_u64(97);
-    let __v_32: G = G::from_u64(0);
-    let __v_33: G = G::from_u64(114);
-    let __v_34: G = G::from_u64(0);
-    let __v_35: G = G::from_u64(107);
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = G::from_u64(47);
-    let __v_38: G = G::from_u64(0);
-    let __v_39: G = G::from_u64(118);
-    let __v_40: G = G::from_u64(0);
-    let __v_41: G = G::from_u64(48);
-    let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_56: G = G::from_u64(1);
-    let __v_57: G = G::from_u64(1);
-    let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-    let __v_59: G = __r_arr[0];
-    let __v_60: G = __r_arr[1];
-    let __v_61: G = __r_arr[2];
-    let __v_62: G = __r_arr[3];
-    let __v_63: G = __r_arr[4];
-    let __v_64: G = __r_arr[5];
-    let __v_65: G = __r_arr[6];
-    let __v_66: G = __r_arr[7];
-    let __v_67: G = __r_arr[8];
-    let __v_68: G = __r_arr[9];
-    let __v_69: G = __r_arr[10];
-    let __v_70: G = __r_arr[11];
-    let __v_71: G = __r_arr[12];
-    let __v_72: G = __r_arr[13];
-    let __v_73: G = __r_arr[14];
-    let __v_74: G = __r_arr[15];
-    let __v_75: G = __r_arr[16];
-    let __v_76: G = __r_arr[17];
-    let __v_77: G = G::from_u64(1);
-    let __v_78: G = G::from_u64(1);
-    let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_80: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_81: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_82: G = __r_arr[0];
-    let __v_83: G = G::from_u64(1);
-    let __v_84: G = G::from_u64(1);
-    let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-    let __v_86: G = __r_arr[0];
-    let __v_87: G = __r_arr[1];
-    let __v_88: G = __r_arr[2];
-    let __v_89: G = __r_arr[3];
-    let __v_90: G = __r_arr[4];
-    let __v_91: G = __r_arr[5];
-    let __v_92: G = __r_arr[6];
-    let __v_93: G = __r_arr[7];
-    let __v_94: G = __r_arr[8];
-    let __v_95: G = __r_arr[9];
-    let __v_96: G = __r_arr[10];
-    let __v_97: G = __r_arr[11];
-    let __v_98: G = __r_arr[12];
-    let __v_99: G = __r_arr[13];
-    let __v_100: G = __r_arr[14];
-    let __v_101: G = __r_arr[15];
-    let __v_102: G = __r_arr[16];
-    let __v_103: G = __r_arr[17];
-    let __v_104: G = G::from_u64(1);
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = __r_arr[2];
+    let __v_14: G = __r_arr[3];
+    let __v_15: G = __r_arr[4];
+    let __v_16: G = __r_arr[5];
+    let __v_17: G = __r_arr[6];
+    let __v_18: G = __r_arr[7];
+    let __v_19: G = __r_arr[8];
+    let __v_20: G = __r_arr[9];
+    let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+    let __v_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __v_23: G = __r_arr[2];
+    let __v_24: G = __r_arr[3];
+    let __v_25: G = __r_arr[4];
+    let __v_26: G = __r_arr[5];
+    let __v_27: G = __r_arr[6];
+    let __v_28: G = __r_arr[7];
+    let __v_29: G = __r_arr[8];
+    let __v_30: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __v_33: G = __r_arr[2];
+    let __v_34: G = __r_arr[3];
+    let __v_35: G = __r_arr[4];
+    let __v_36: G = __r_arr[5];
+    let __v_37: G = __r_arr[6];
+    let __v_38: G = __r_arr[7];
+    let __v_39: G = __r_arr[8];
+    let __v_40: G = __r_arr[9];
+    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __v_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+    let __v_43: G = __r_arr[0];
+    let __v_44: G = __r_arr[1];
+    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_44, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+    let __v_45: G = __r_arr[0];
+    let __v_46: G = __r_arr[1];
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+    let __v_47: G = __r_arr[0];
+    let __v_48: G = __r_arr[1];
+    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_48, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = __r_arr[0];
+    let __v_50: G = __r_arr[1];
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_52, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+    let __v_53: G = __r_arr[0];
+    let __v_54: G = __r_arr[1];
+    let __v_55: G = G::from_u64(0);
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_51, __v_55, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __v_56: G = __r_arr[0];
+    let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+    let __v_58: G = (__v_56 + __v_57);
+    let __v_59: G = (__v_58 + __v_58);
+    let __v_60: G = (__v_47 + __v_59);
+    let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes();
+    let __v_61: G = G::from_u8(__gb[0]);
+    let __v_62: G = G::from_u8(__gb[1]);
+    let __v_63: G = G::from_u8(__gb[2]);
+    let __v_64: G = G::from_u8(__gb[3]);
+    let __v_65: G = G::from_u8(__gb[4]);
+    let __v_66: G = G::from_u8(__gb[5]);
+    let __v_67: G = G::from_u8(__gb[6]);
+    let __v_68: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_61; let __vj = __v_62; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_63; let __vj = __v_64; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_65; let __vj = __v_66; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_67; let __vj = __v_68; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_69: G = G::from_u64(1020);
+    let __v_70: G = (__v_68 - __v_69);
+    let __v_71: G = (__v_67 + __v_70);
+    let __v_72: G = (__v_66 + __v_71);
+    let __v_73: G = (__v_65 + __v_72);
+    let __v_74: G = G::from_bool((__v_73 == G::ZERO));
+    let __v_75: G = (__v_63 + __v_64);
+    let __v_76: G = (__v_62 + __v_75);
+    let __v_77: G = (__v_61 + __v_76);
+    let __v_78: G = G::from_bool((__v_77 == G::ZERO));
+    let __v_79: G = G::from_u64(256);
+    let __v_80: G = (__v_79 * __v_62);
+    let __v_81: G = G::from_u64(65536);
+    let __v_82: G = (__v_81 * __v_63);
+    let __v_83: G = G::from_u64(16777216);
+    let __v_84: G = (__v_83 * __v_64);
+    let __v_85: G = G::from_u64(4294967296);
+    let __v_86: G = (__v_85 * __v_65);
+    let __v_87: G = G::from_u64(1099511627776);
+    let __v_88: G = (__v_87 * __v_66);
+    let __v_89: G = G::from_u64(281474976710656);
+    let __v_90: G = (__v_89 * __v_67);
+    let __v_91: G = G::from_u64(72057594037927936);
+    let __v_92: G = (__v_91 * __v_68);
+    let __v_93: G = (__v_90 + __v_92);
+    let __v_94: G = (__v_88 + __v_93);
+    let __v_95: G = (__v_86 + __v_94);
+    let __v_96: G = (__v_84 + __v_95);
+    let __v_97: G = (__v_82 + __v_96);
+    let __v_98: G = (__v_80 + __v_97);
+    let __v_99: G = (__v_61 + __v_98);
+    if (__v_99 != __v_60) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+    }
+    let __v_100: G = G::from_u64(1);
+    let __v_101: G = G::from_u64(1);
+    let __v_102: G = (__v_101 - __v_78);
+    let __v_103: G = (__v_74 * __v_102);
+    let __v_104: G = (__v_100 - __v_103);
     let __v_105: G = G::from_u64(1);
-    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_107: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_108: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_109: G = __r_arr[0];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-    let __v_110: G = __r_arr[0];
-    let __v_111: G = G::from_u64(1);
-    let __v_112: G = G::from_u64(1);
-    let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-    let __v_114: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_115: G = __r_arr[0];
-    let __v_116: G = G::from_u64(1);
-    let __v_117: G = G::from_u64(1);
-    let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-    let __v_119: G = __r_arr[0];
-    let __v_120: G = __r_arr[1];
-    let __v_121: G = __r_arr[2];
-    let __v_122: G = __r_arr[3];
-    let __v_123: G = __r_arr[4];
-    let __v_124: G = __r_arr[5];
-    let __v_125: G = __r_arr[6];
-    let __v_126: G = __r_arr[7];
-    let __v_127: G = __r_arr[8];
-    let __v_128: G = __r_arr[9];
-    let __v_129: G = __r_arr[10];
-    let __v_130: G = __r_arr[11];
-    let __v_131: G = __r_arr[12];
-    let __v_132: G = __r_arr[13];
-    let __v_133: G = __r_arr[14];
-    let __v_134: G = __r_arr[15];
-    let __v_135: G = __r_arr[16];
-    let __v_136: G = __r_arr[17];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-    let __v_137: G = __r_arr[0];
-    let __v_138: G = G::from_u64(1);
-    let __v_139: G = G::from_u64(1);
-    let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-    let __v_141: G = __r_arr[0];
-    let __v_142: G = __r_arr[1];
-    let __v_143: G = __r_arr[2];
-    let __v_144: G = __r_arr[3];
-    let __v_145: G = __r_arr[4];
-    let __v_146: G = __r_arr[5];
-    let __v_147: G = __r_arr[6];
-    let __v_148: G = __r_arr[7];
-    let __v_149: G = __r_arr[8];
-    let __v_150: G = __r_arr[9];
-    let __v_151: G = __r_arr[10];
-    let __v_152: G = __r_arr[11];
-    let __v_153: G = __r_arr[12];
-    let __v_154: G = __r_arr[13];
-    let __v_155: G = __r_arr[14];
-    let __v_156: G = __r_arr[15];
-    let __v_157: G = __r_arr[16];
-    let __v_158: G = __r_arr[17];
-    let __v_159: G = G::from_u64(256);
-    let __v_160: G = (__v_159 * __v_60);
-    let __v_161: G = G::from_u64(65536);
-    let __v_162: G = (__v_161 * __v_61);
-    let __v_163: G = G::from_u64(16777216);
-    let __v_164: G = (__v_163 * __v_62);
-    let __v_165: G = G::from_u64(4294967296);
-    let __v_166: G = (__v_165 * __v_63);
-    let __v_167: G = G::from_u64(1099511627776);
-    let __v_168: G = (__v_167 * __v_64);
-    let __v_169: G = G::from_u64(281474976710656);
-    let __v_170: G = (__v_169 * __v_65);
-    let __v_171: G = G::from_u64(72057594037927936);
-    let __v_172: G = (__v_171 * __v_66);
-    let __v_173: G = (__v_170 + __v_172);
-    let __v_174: G = (__v_168 + __v_173);
-    let __v_175: G = (__v_166 + __v_174);
-    let __v_176: G = (__v_164 + __v_175);
-    let __v_177: G = (__v_162 + __v_176);
-    let __v_178: G = (__v_160 + __v_177);
-    let __v_179: G = (__v_59 + __v_178);
-    let __v_180: G = G::from_u64(256);
-    let __v_181: G = (__v_180 * __v_68);
-    let __v_182: G = G::from_u64(65536);
-    let __v_183: G = (__v_182 * __v_69);
-    let __v_184: G = G::from_u64(16777216);
-    let __v_185: G = (__v_184 * __v_70);
-    let __v_186: G = G::from_u64(4294967296);
-    let __v_187: G = (__v_186 * __v_71);
-    let __v_188: G = G::from_u64(1099511627776);
-    let __v_189: G = (__v_188 * __v_72);
-    let __v_190: G = G::from_u64(281474976710656);
-    let __v_191: G = (__v_190 * __v_73);
-    let __v_192: G = G::from_u64(72057594037927936);
-    let __v_193: G = (__v_192 * __v_74);
-    let __v_194: G = (__v_191 + __v_193);
-    let __v_195: G = (__v_189 + __v_194);
-    let __v_196: G = (__v_187 + __v_195);
-    let __v_197: G = (__v_185 + __v_196);
-    let __v_198: G = (__v_183 + __v_197);
-    let __v_199: G = (__v_181 + __v_198);
-    let __v_200: G = (__v_67 + __v_199);
-    let __v_201: G = G::from_u64(256);
-    let __v_202: G = (__v_201 * __v_87);
-    let __v_203: G = G::from_u64(65536);
-    let __v_204: G = (__v_203 * __v_88);
-    let __v_205: G = G::from_u64(16777216);
-    let __v_206: G = (__v_205 * __v_89);
-    let __v_207: G = G::from_u64(4294967296);
-    let __v_208: G = (__v_207 * __v_90);
-    let __v_209: G = G::from_u64(1099511627776);
-    let __v_210: G = (__v_209 * __v_91);
-    let __v_211: G = G::from_u64(281474976710656);
-    let __v_212: G = (__v_211 * __v_92);
-    let __v_213: G = G::from_u64(72057594037927936);
-    let __v_214: G = (__v_213 * __v_93);
-    let __v_215: G = (__v_212 + __v_214);
-    let __v_216: G = (__v_210 + __v_215);
-    let __v_217: G = (__v_208 + __v_216);
-    let __v_218: G = (__v_206 + __v_217);
-    let __v_219: G = (__v_204 + __v_218);
-    let __v_220: G = (__v_202 + __v_219);
-    let __v_221: G = (__v_86 + __v_220);
-    let __v_222: G = G::from_u64(256);
-    let __v_223: G = (__v_222 * __v_95);
-    let __v_224: G = G::from_u64(65536);
-    let __v_225: G = (__v_224 * __v_96);
-    let __v_226: G = G::from_u64(16777216);
-    let __v_227: G = (__v_226 * __v_97);
-    let __v_228: G = G::from_u64(4294967296);
-    let __v_229: G = (__v_228 * __v_98);
-    let __v_230: G = G::from_u64(1099511627776);
-    let __v_231: G = (__v_230 * __v_99);
-    let __v_232: G = G::from_u64(281474976710656);
-    let __v_233: G = (__v_232 * __v_100);
-    let __v_234: G = G::from_u64(72057594037927936);
-    let __v_235: G = (__v_234 * __v_101);
-    let __v_236: G = (__v_233 + __v_235);
-    let __v_237: G = (__v_231 + __v_236);
-    let __v_238: G = (__v_229 + __v_237);
-    let __v_239: G = (__v_227 + __v_238);
-    let __v_240: G = (__v_225 + __v_239);
-    let __v_241: G = (__v_223 + __v_240);
-    let __v_242: G = (__v_94 + __v_241);
-    let __v_243: G = G::from_u64(256);
-    let __v_244: G = (__v_243 * __v_120);
-    let __v_245: G = G::from_u64(65536);
-    let __v_246: G = (__v_245 * __v_121);
-    let __v_247: G = G::from_u64(16777216);
-    let __v_248: G = (__v_247 * __v_122);
-    let __v_249: G = G::from_u64(4294967296);
-    let __v_250: G = (__v_249 * __v_123);
-    let __v_251: G = G::from_u64(1099511627776);
-    let __v_252: G = (__v_251 * __v_124);
-    let __v_253: G = G::from_u64(281474976710656);
-    let __v_254: G = (__v_253 * __v_125);
-    let __v_255: G = G::from_u64(72057594037927936);
-    let __v_256: G = (__v_255 * __v_126);
-    let __v_257: G = (__v_254 + __v_256);
-    let __v_258: G = (__v_252 + __v_257);
-    let __v_259: G = (__v_250 + __v_258);
-    let __v_260: G = (__v_248 + __v_259);
-    let __v_261: G = (__v_246 + __v_260);
-    let __v_262: G = (__v_244 + __v_261);
-    let __v_263: G = (__v_119 + __v_262);
-    let __v_264: G = G::from_u64(256);
-    let __v_265: G = (__v_264 * __v_128);
-    let __v_266: G = G::from_u64(65536);
-    let __v_267: G = (__v_266 * __v_129);
-    let __v_268: G = G::from_u64(16777216);
-    let __v_269: G = (__v_268 * __v_130);
-    let __v_270: G = G::from_u64(4294967296);
-    let __v_271: G = (__v_270 * __v_131);
-    let __v_272: G = G::from_u64(1099511627776);
-    let __v_273: G = (__v_272 * __v_132);
-    let __v_274: G = G::from_u64(281474976710656);
-    let __v_275: G = (__v_274 * __v_133);
-    let __v_276: G = G::from_u64(72057594037927936);
-    let __v_277: G = (__v_276 * __v_134);
-    let __v_278: G = (__v_275 + __v_277);
-    let __v_279: G = (__v_273 + __v_278);
-    let __v_280: G = (__v_271 + __v_279);
-    let __v_281: G = (__v_269 + __v_280);
-    let __v_282: G = (__v_267 + __v_281);
-    let __v_283: G = (__v_265 + __v_282);
-    let __v_284: G = (__v_127 + __v_283);
-    let __v_285: G = G::from_u64(256);
-    let __v_286: G = (__v_285 * __v_142);
-    let __v_287: G = G::from_u64(65536);
-    let __v_288: G = (__v_287 * __v_143);
-    let __v_289: G = G::from_u64(16777216);
-    let __v_290: G = (__v_289 * __v_144);
-    let __v_291: G = G::from_u64(4294967296);
-    let __v_292: G = (__v_291 * __v_145);
-    let __v_293: G = G::from_u64(1099511627776);
-    let __v_294: G = (__v_293 * __v_146);
-    let __v_295: G = G::from_u64(281474976710656);
-    let __v_296: G = (__v_295 * __v_147);
-    let __v_297: G = G::from_u64(72057594037927936);
-    let __v_298: G = (__v_297 * __v_148);
-    let __v_299: G = (__v_296 + __v_298);
-    let __v_300: G = (__v_294 + __v_299);
-    let __v_301: G = (__v_292 + __v_300);
-    let __v_302: G = (__v_290 + __v_301);
-    let __v_303: G = (__v_288 + __v_302);
-    let __v_304: G = (__v_286 + __v_303);
-    let __v_305: G = (__v_141 + __v_304);
-    let __v_306: G = G::from_u64(256);
-    let __v_307: G = (__v_306 * __v_150);
-    let __v_308: G = G::from_u64(65536);
-    let __v_309: G = (__v_308 * __v_151);
-    let __v_310: G = G::from_u64(16777216);
-    let __v_311: G = (__v_310 * __v_152);
-    let __v_312: G = G::from_u64(4294967296);
-    let __v_313: G = (__v_312 * __v_153);
-    let __v_314: G = G::from_u64(1099511627776);
-    let __v_315: G = (__v_314 * __v_154);
-    let __v_316: G = G::from_u64(281474976710656);
-    let __v_317: G = (__v_316 * __v_155);
-    let __v_318: G = G::from_u64(72057594037927936);
-    let __v_319: G = (__v_318 * __v_156);
-    let __v_320: G = (__v_317 + __v_319);
-    let __v_321: G = (__v_315 + __v_320);
-    let __v_322: G = (__v_313 + __v_321);
-    let __v_323: G = (__v_311 + __v_322);
-    let __v_324: G = (__v_309 + __v_323);
-    let __v_325: G = (__v_307 + __v_324);
-    let __v_326: G = (__v_149 + __v_325);
-    let __ret: [G; OUT_160] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157];
-    if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if (__v_104 != __v_105) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_105.as_canonical_u64(), msg: None });
+    }
+    let __v_106: G = (__v_58 + __v_58);
+    let __gb: [u8; 8] = __v_106.as_canonical_u64().to_le_bytes();
+    let __v_107: G = G::from_u8(__gb[0]);
+    let __v_108: G = G::from_u8(__gb[1]);
+    let __v_109: G = G::from_u8(__gb[2]);
+    let __v_110: G = G::from_u8(__gb[3]);
+    let __v_111: G = G::from_u8(__gb[4]);
+    let __v_112: G = G::from_u8(__gb[5]);
+    let __v_113: G = G::from_u8(__gb[6]);
+    let __v_114: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_107; let __vj = __v_108; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_109; let __vj = __v_110; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_111; let __vj = __v_112; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_113; let __vj = __v_114; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_115: G = G::from_u64(1020);
+    let __v_116: G = (__v_114 - __v_115);
+    let __v_117: G = (__v_113 + __v_116);
+    let __v_118: G = (__v_112 + __v_117);
+    let __v_119: G = (__v_111 + __v_118);
+    let __v_120: G = G::from_bool((__v_119 == G::ZERO));
+    let __v_121: G = (__v_109 + __v_110);
+    let __v_122: G = (__v_108 + __v_121);
+    let __v_123: G = (__v_107 + __v_122);
+    let __v_124: G = G::from_bool((__v_123 == G::ZERO));
+    let __v_125: G = G::from_u64(256);
+    let __v_126: G = (__v_125 * __v_108);
+    let __v_127: G = G::from_u64(65536);
+    let __v_128: G = (__v_127 * __v_109);
+    let __v_129: G = G::from_u64(16777216);
+    let __v_130: G = (__v_129 * __v_110);
+    let __v_131: G = G::from_u64(4294967296);
+    let __v_132: G = (__v_131 * __v_111);
+    let __v_133: G = G::from_u64(1099511627776);
+    let __v_134: G = (__v_133 * __v_112);
+    let __v_135: G = G::from_u64(281474976710656);
+    let __v_136: G = (__v_135 * __v_113);
+    let __v_137: G = G::from_u64(72057594037927936);
+    let __v_138: G = (__v_137 * __v_114);
+    let __v_139: G = (__v_136 + __v_138);
+    let __v_140: G = (__v_134 + __v_139);
+    let __v_141: G = (__v_132 + __v_140);
+    let __v_142: G = (__v_130 + __v_141);
+    let __v_143: G = (__v_128 + __v_142);
+    let __v_144: G = (__v_126 + __v_143);
+    let __v_145: G = (__v_107 + __v_144);
+    if (__v_145 != __v_106) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None });
+    }
+    let __v_146: G = G::from_u64(1);
+    let __v_147: G = G::from_u64(1);
+    let __v_148: G = (__v_147 - __v_124);
+    let __v_149: G = (__v_120 * __v_148);
+    let __v_150: G = (__v_146 - __v_149);
+    let __v_151: G = G::from_u64(1);
+    if (__v_150 != __v_151) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_151.as_canonical_u64(), msg: None });
+    }
+    let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes();
+    let __v_152: G = G::from_u8(__gb[0]);
+    let __v_153: G = G::from_u8(__gb[1]);
+    let __v_154: G = G::from_u8(__gb[2]);
+    let __v_155: G = G::from_u8(__gb[3]);
+    let __v_156: G = G::from_u8(__gb[4]);
+    let __v_157: G = G::from_u8(__gb[5]);
+    let __v_158: G = G::from_u8(__gb[6]);
+    let __v_159: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_152; let __vj = __v_153; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_154; let __vj = __v_155; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_156; let __vj = __v_157; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_158; let __vj = __v_159; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_160: G = G::from_u64(1020);
+    let __v_161: G = (__v_159 - __v_160);
+    let __v_162: G = (__v_158 + __v_161);
+    let __v_163: G = (__v_157 + __v_162);
+    let __v_164: G = (__v_156 + __v_163);
+    let __v_165: G = G::from_bool((__v_164 == G::ZERO));
+    let __v_166: G = (__v_154 + __v_155);
+    let __v_167: G = (__v_153 + __v_166);
+    let __v_168: G = (__v_152 + __v_167);
+    let __v_169: G = G::from_bool((__v_168 == G::ZERO));
+    let __v_170: G = G::from_u64(256);
+    let __v_171: G = (__v_170 * __v_153);
+    let __v_172: G = G::from_u64(65536);
+    let __v_173: G = (__v_172 * __v_154);
+    let __v_174: G = G::from_u64(16777216);
+    let __v_175: G = (__v_174 * __v_155);
+    let __v_176: G = G::from_u64(4294967296);
+    let __v_177: G = (__v_176 * __v_156);
+    let __v_178: G = G::from_u64(1099511627776);
+    let __v_179: G = (__v_178 * __v_157);
+    let __v_180: G = G::from_u64(281474976710656);
+    let __v_181: G = (__v_180 * __v_158);
+    let __v_182: G = G::from_u64(72057594037927936);
+    let __v_183: G = (__v_182 * __v_159);
+    let __v_184: G = (__v_181 + __v_183);
+    let __v_185: G = (__v_179 + __v_184);
+    let __v_186: G = (__v_177 + __v_185);
+    let __v_187: G = (__v_175 + __v_186);
+    let __v_188: G = (__v_173 + __v_187);
+    let __v_189: G = (__v_171 + __v_188);
+    let __v_190: G = (__v_152 + __v_189);
+    if (__v_190 != __v_41) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None });
+    }
+    let __v_191: G = G::from_u64(1);
+    let __v_192: G = G::from_u64(1);
+    let __v_193: G = (__v_192 - __v_169);
+    let __v_194: G = (__v_165 * __v_193);
+    let __v_195: G = (__v_191 - __v_194);
+    let __v_196: G = G::from_u64(1);
+    if (__v_195 != __v_196) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_96] = [__v_45, __v_43, __v_49, __v_31, __v_53, __v_41, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_54];
+    if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_97: usize = 57;
+const IN_97: usize = 57;
+const OUT_97: usize = 1;
+fn aiur_fn_97(
+  inp: [G; IN_97],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_97], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = G::from_u64(0);
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = G::from_u64(0);
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_97] = [__v_70];
+    if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_98: usize = 2;
+const IN_98: usize = 2;
+const OUT_98: usize = 3;
+fn aiur_fn_98(
+  inp: [G; IN_98],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_98], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_98] = [__v_4, __v_7, __v_0];
+        if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = __r_arr[9];
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __v_14: G = __r_arr[2];
+        let __v_15: G = __r_arr[3];
+        let __v_16: G = __r_arr[4];
+        let __v_17: G = __r_arr[5];
+        let __v_18: G = __r_arr[6];
+        let __v_19: G = __r_arr[7];
+        let __v_20: G = __r_arr[8];
+        let __v_21: G = __r_arr[9];
+        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __v_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __v_24: G = __r_arr[2];
+        let __v_25: G = __r_arr[3];
+        let __v_26: G = __r_arr[4];
+        let __v_27: G = __r_arr[5];
+        let __v_28: G = __r_arr[6];
+        let __v_29: G = __r_arr[7];
+        let __v_30: G = __r_arr[8];
+        let __v_31: G = __r_arr[9];
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+        let __v_32: G = __r_arr[0];
+        let __v_33: G = __r_arr[1];
+        let __v_34: G = __r_arr[2];
+        let __v_35: G = __r_arr[3];
+        let __v_36: G = __r_arr[4];
+        let __v_37: G = __r_arr[5];
+        let __v_38: G = __r_arr[6];
+        let __v_39: G = __r_arr[7];
+        let __v_40: G = __r_arr[8];
+        let __v_41: G = __r_arr[9];
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __v_42: G = __r_arr[0];
+        let __v_43: G = __r_arr[1];
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+        let __v_46: G = __r_arr[0];
+        let __v_47: G = __r_arr[1];
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __v_48: G = __r_arr[0];
+        let __v_49: G = __r_arr[1];
+        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_49, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+        let __v_50: G = __r_arr[0];
+        let __v_51: G = __r_arr[1];
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __v_52: G = __r_arr[0];
+        let __v_53: G = __r_arr[1];
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_53, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __v_54: G = __r_arr[0];
+        let __v_55: G = __r_arr[1];
+        let __v_56: G = G::from_u64(0);
+        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_52, __v_56, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __v_58: G = G::from_bool((__v_57 == G::ZERO));
+        let __v_59: G = (__v_57 + __v_58);
+        let __v_60: G = (__v_59 + __v_59);
+        let __v_61: G = (__v_48 + __v_60);
+        let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes();
+        let __v_62: G = G::from_u8(__gb[0]);
+        let __v_63: G = G::from_u8(__gb[1]);
+        let __v_64: G = G::from_u8(__gb[2]);
+        let __v_65: G = G::from_u8(__gb[3]);
+        let __v_66: G = G::from_u8(__gb[4]);
+        let __v_67: G = G::from_u8(__gb[5]);
+        let __v_68: G = G::from_u8(__gb[6]);
+        let __v_69: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_66; let __vj = __v_67; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_68; let __vj = __v_69; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_70: G = G::from_u64(1020);
+        let __v_71: G = (__v_69 - __v_70);
+        let __v_72: G = (__v_68 + __v_71);
+        let __v_73: G = (__v_67 + __v_72);
+        let __v_74: G = (__v_66 + __v_73);
+        let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+        let __v_76: G = (__v_64 + __v_65);
+        let __v_77: G = (__v_63 + __v_76);
+        let __v_78: G = (__v_62 + __v_77);
+        let __v_79: G = G::from_bool((__v_78 == G::ZERO));
+        let __v_80: G = G::from_u64(256);
+        let __v_81: G = (__v_80 * __v_63);
+        let __v_82: G = G::from_u64(65536);
+        let __v_83: G = (__v_82 * __v_64);
+        let __v_84: G = G::from_u64(16777216);
+        let __v_85: G = (__v_84 * __v_65);
+        let __v_86: G = G::from_u64(4294967296);
+        let __v_87: G = (__v_86 * __v_66);
+        let __v_88: G = G::from_u64(1099511627776);
+        let __v_89: G = (__v_88 * __v_67);
+        let __v_90: G = G::from_u64(281474976710656);
+        let __v_91: G = (__v_90 * __v_68);
+        let __v_92: G = G::from_u64(72057594037927936);
+        let __v_93: G = (__v_92 * __v_69);
+        let __v_94: G = (__v_91 + __v_93);
+        let __v_95: G = (__v_89 + __v_94);
+        let __v_96: G = (__v_87 + __v_95);
+        let __v_97: G = (__v_85 + __v_96);
+        let __v_98: G = (__v_83 + __v_97);
+        let __v_99: G = (__v_81 + __v_98);
+        let __v_100: G = (__v_62 + __v_99);
+        if (__v_100 != __v_61) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_100.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
+        }
+        let __v_101: G = G::from_u64(1);
+        let __v_102: G = G::from_u64(1);
+        let __v_103: G = (__v_102 - __v_79);
+        let __v_104: G = (__v_75 * __v_103);
+        let __v_105: G = (__v_101 - __v_104);
+        let __v_106: G = G::from_u64(1);
+        if (__v_105 != __v_106) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None });
+        }
+        let __v_107: G = (__v_59 + __v_59);
+        let __gb: [u8; 8] = __v_107.as_canonical_u64().to_le_bytes();
+        let __v_108: G = G::from_u8(__gb[0]);
+        let __v_109: G = G::from_u8(__gb[1]);
+        let __v_110: G = G::from_u8(__gb[2]);
+        let __v_111: G = G::from_u8(__gb[3]);
+        let __v_112: G = G::from_u8(__gb[4]);
+        let __v_113: G = G::from_u8(__gb[5]);
+        let __v_114: G = G::from_u8(__gb[6]);
+        let __v_115: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_108; let __vj = __v_109; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_110; let __vj = __v_111; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_112; let __vj = __v_113; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_114; let __vj = __v_115; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_116: G = G::from_u64(1020);
+        let __v_117: G = (__v_115 - __v_116);
+        let __v_118: G = (__v_114 + __v_117);
+        let __v_119: G = (__v_113 + __v_118);
+        let __v_120: G = (__v_112 + __v_119);
+        let __v_121: G = G::from_bool((__v_120 == G::ZERO));
+        let __v_122: G = (__v_110 + __v_111);
+        let __v_123: G = (__v_109 + __v_122);
+        let __v_124: G = (__v_108 + __v_123);
+        let __v_125: G = G::from_bool((__v_124 == G::ZERO));
+        let __v_126: G = G::from_u64(256);
+        let __v_127: G = (__v_126 * __v_109);
+        let __v_128: G = G::from_u64(65536);
+        let __v_129: G = (__v_128 * __v_110);
+        let __v_130: G = G::from_u64(16777216);
+        let __v_131: G = (__v_130 * __v_111);
+        let __v_132: G = G::from_u64(4294967296);
+        let __v_133: G = (__v_132 * __v_112);
+        let __v_134: G = G::from_u64(1099511627776);
+        let __v_135: G = (__v_134 * __v_113);
+        let __v_136: G = G::from_u64(281474976710656);
+        let __v_137: G = (__v_136 * __v_114);
+        let __v_138: G = G::from_u64(72057594037927936);
+        let __v_139: G = (__v_138 * __v_115);
+        let __v_140: G = (__v_137 + __v_139);
+        let __v_141: G = (__v_135 + __v_140);
+        let __v_142: G = (__v_133 + __v_141);
+        let __v_143: G = (__v_131 + __v_142);
+        let __v_144: G = (__v_129 + __v_143);
+        let __v_145: G = (__v_127 + __v_144);
+        let __v_146: G = (__v_108 + __v_145);
+        if (__v_146 != __v_107) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_107.as_canonical_u64(), msg: None });
+        }
+        let __v_147: G = G::from_u64(1);
+        let __v_148: G = G::from_u64(1);
+        let __v_149: G = (__v_148 - __v_125);
+        let __v_150: G = (__v_121 * __v_149);
+        let __v_151: G = (__v_147 - __v_150);
+        let __v_152: G = G::from_u64(1);
+        if (__v_151 != __v_152) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_152.as_canonical_u64(), msg: None });
+        }
+        let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes();
+        let __v_153: G = G::from_u8(__gb[0]);
+        let __v_154: G = G::from_u8(__gb[1]);
+        let __v_155: G = G::from_u8(__gb[2]);
+        let __v_156: G = G::from_u8(__gb[3]);
+        let __v_157: G = G::from_u8(__gb[4]);
+        let __v_158: G = G::from_u8(__gb[5]);
+        let __v_159: G = G::from_u8(__gb[6]);
+        let __v_160: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_153; let __vj = __v_154; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_155; let __vj = __v_156; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_157; let __vj = __v_158; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_159; let __vj = __v_160; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_161: G = G::from_u64(1020);
+        let __v_162: G = (__v_160 - __v_161);
+        let __v_163: G = (__v_159 + __v_162);
+        let __v_164: G = (__v_158 + __v_163);
+        let __v_165: G = (__v_157 + __v_164);
+        let __v_166: G = G::from_bool((__v_165 == G::ZERO));
+        let __v_167: G = (__v_155 + __v_156);
+        let __v_168: G = (__v_154 + __v_167);
+        let __v_169: G = (__v_153 + __v_168);
+        let __v_170: G = G::from_bool((__v_169 == G::ZERO));
+        let __v_171: G = G::from_u64(256);
+        let __v_172: G = (__v_171 * __v_154);
+        let __v_173: G = G::from_u64(65536);
+        let __v_174: G = (__v_173 * __v_155);
+        let __v_175: G = G::from_u64(16777216);
+        let __v_176: G = (__v_175 * __v_156);
+        let __v_177: G = G::from_u64(4294967296);
+        let __v_178: G = (__v_177 * __v_157);
+        let __v_179: G = G::from_u64(1099511627776);
+        let __v_180: G = (__v_179 * __v_158);
+        let __v_181: G = G::from_u64(281474976710656);
+        let __v_182: G = (__v_181 * __v_159);
+        let __v_183: G = G::from_u64(72057594037927936);
+        let __v_184: G = (__v_183 * __v_160);
+        let __v_185: G = (__v_182 + __v_184);
+        let __v_186: G = (__v_180 + __v_185);
+        let __v_187: G = (__v_178 + __v_186);
+        let __v_188: G = (__v_176 + __v_187);
+        let __v_189: G = (__v_174 + __v_188);
+        let __v_190: G = (__v_172 + __v_189);
+        let __v_191: G = (__v_153 + __v_190);
+        if (__v_191 != __v_42) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_191.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None });
+        }
+        let __v_192: G = G::from_u64(1);
+        let __v_193: G = G::from_u64(1);
+        let __v_194: G = (__v_193 - __v_170);
+        let __v_195: G = (__v_166 * __v_194);
+        let __v_196: G = (__v_192 - __v_195);
+        let __v_197: G = G::from_u64(1);
+        if (__v_196 != __v_197) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_196.as_canonical_u64(), rhs: __v_197.as_canonical_u64(), msg: None });
+        }
+        let __v_198: G = G::from_u64(1);
+        let __v_199: G = (__v_1 - __v_198);
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_55, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_200: G = __r_arr[0];
+        let __v_201: G = __r_arr[1];
+        let __v_202: G = __r_arr[2];
+        let __v_203: G = G::from_u64(0);
+        let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_205: G = G::from_u64(0);
+        let __v_206: G = G::from_u64(0);
+        let __v_207: G = G::from_u64(0);
+        let __v_208: G = G::from_u64(0);
+        let __v_209: G = G::from_u64(0);
+        let __v_210: G = G::from_u64(0);
+        let __v_211: G = G::from_u64(0);
+        let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_98] = [__v_204, __v_218, __v_202];
+        if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_99: usize = 1;
+const IN_99: usize = 1;
+const OUT_99: usize = 3;
+fn aiur_fn_99(
+  inp: [G; IN_99],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_99], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_99] = [__v_3, __v_4, __v_2];
+        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __v_7: G = G::from_u64(1);
+        let __ret: [G; OUT_99] = [__v_7, __v_5, __v_6];
+        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_100: usize = 2;
+const IN_100: usize = 2;
+const OUT_100: usize = 2;
+fn aiur_fn_100(
+  inp: [G; IN_100],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_100], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_100] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        match __v_2.as_canonical_u64() {
+          65535u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_100] = [__v_11, __v_7];
+            if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_100] = [__v_10, __v_7];
+            if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_101: usize = 1;
+const IN_101: usize = 1;
+const OUT_101: usize = 13;
+fn aiur_fn_101(
+  inp: [G; IN_101],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_101], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = __r_arr[2];
+    let __v_14: G = __r_arr[3];
+    let __v_15: G = __r_arr[4];
+    let __v_16: G = __r_arr[5];
+    let __v_17: G = __r_arr[6];
+    let __v_18: G = __r_arr[7];
+    let __v_19: G = __r_arr[8];
+    let __v_20: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __v_23: G = __r_arr[2];
+    let __v_24: G = __r_arr[3];
+    let __v_25: G = __r_arr[4];
+    let __v_26: G = __r_arr[5];
+    let __v_27: G = __r_arr[6];
+    let __v_28: G = __r_arr[7];
+    let __v_29: G = __r_arr[8];
+    let __v_30: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __v_33: G = __r_arr[2];
+    let __v_34: G = __r_arr[3];
+    let __v_35: G = __r_arr[4];
+    let __v_36: G = __r_arr[5];
+    let __v_37: G = __r_arr[6];
+    let __v_38: G = __r_arr[7];
+    let __v_39: G = __r_arr[8];
+    let __v_40: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __v_43: G = __r_arr[2];
+    let __v_44: G = __r_arr[3];
+    let __v_45: G = __r_arr[4];
+    let __v_46: G = __r_arr[5];
+    let __v_47: G = __r_arr[6];
+    let __v_48: G = __r_arr[7];
+    let __v_49: G = __r_arr[8];
+    let __v_50: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __v_53: G = __r_arr[2];
+    let __v_54: G = __r_arr[3];
+    let __v_55: G = __r_arr[4];
+    let __v_56: G = __r_arr[5];
+    let __v_57: G = __r_arr[6];
+    let __v_58: G = __r_arr[7];
+    let __v_59: G = __r_arr[8];
+    let __v_60: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_61: G = __r_arr[0];
+    let __v_62: G = __r_arr[1];
+    let __v_63: G = __r_arr[2];
+    let __v_64: G = __r_arr[3];
+    let __v_65: G = __r_arr[4];
+    let __v_66: G = __r_arr[5];
+    let __v_67: G = __r_arr[6];
+    let __v_68: G = __r_arr[7];
+    let __v_69: G = __r_arr[8];
+    let __v_70: G = __r_arr[9];
+    let __v_71: G = G::from_u64(0);
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = G::from_u64(0);
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = G::from_u64(0);
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = G::from_u64(0);
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = G::from_u64(1);
+    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_88: G = __r_arr[0];
+    let __v_89: G = __r_arr[1];
+    let __v_90: G = __r_arr[2];
+    let __v_91: G = __r_arr[3];
+    let __v_92: G = __r_arr[4];
+    let __v_93: G = __r_arr[5];
+    let __v_94: G = __r_arr[6];
+    let __v_95: G = __r_arr[7];
+    let __v_96: G = __r_arr[8];
+    let __v_97: G = __r_arr[9];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_97, __v_88]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_98: G = __r_arr[0];
+    let __v_99: G = __r_arr[1];
+    let __v_100: G = __r_arr[2];
+    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
+    let __v_101: G = __r_arr[0];
+    let __v_102: G = __r_arr[1];
+    let __v_103: G = __r_arr[2];
+    let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_103, __v_88]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
+    let __v_104: G = __r_arr[0];
+    let __v_105: G = __r_arr[1];
+    let __v_106: G = G::from_u64(0);
+    let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+    let __v_108: G = __r_arr[0];
+    let __ret: [G; OUT_101] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_108, __v_98, __v_101, __v_102, __v_104, __v_105];
+    if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_102: usize = 0;
+const IN_102: usize = 0;
+const OUT_102: usize = 1;
+fn aiur_fn_102(
+  inp: [G; IN_102],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_102], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(1);
+    let __v_1: G = G::from_u64(1);
+    let __v_2: G = { let __values: [G; 3] = [__v_0, __v_1, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_102] = [__v_2];
+    if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_103: usize = 1;
+const IN_103: usize = 1;
+const OUT_103: usize = 33;
+fn aiur_fn_103(
+  inp: [G; IN_103],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_103], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __v_21: G = __r_arr[2];
+    let __v_22: G = __r_arr[3];
+    let __v_23: G = __r_arr[4];
+    let __v_24: G = __r_arr[5];
+    let __v_25: G = __r_arr[6];
+    let __v_26: G = __r_arr[7];
+    let __v_27: G = __r_arr[8];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __v_30: G = __r_arr[2];
+    let __v_31: G = __r_arr[3];
+    let __v_32: G = __r_arr[4];
+    let __v_33: G = __r_arr[5];
+    let __v_34: G = __r_arr[6];
+    let __v_35: G = __r_arr[7];
+    let __v_36: G = __r_arr[8];
+    let __ret: [G; OUT_103] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_104: usize = 1;
+const IN_104: usize = 1;
+const OUT_104: usize = 2;
+fn aiur_fn_104(
+  inp: [G; IN_104],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_104], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_104] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_105: usize = 2;
+const IN_105: usize = 2;
+const OUT_105: usize = 2;
+fn aiur_fn_105(
+  inp: [G; IN_105],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_105], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_105] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = __r_arr[2];
+        let __v_14: G = __r_arr[3];
+        let __v_15: G = __r_arr[4];
+        let __v_16: G = __r_arr[5];
+        let __v_17: G = __r_arr[6];
+        let __v_18: G = __r_arr[7];
+        let __v_19: G = __r_arr[8];
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_19]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __v_21: G = __r_arr[1];
+        let __v_22: G = __r_arr[2];
+        let __v_23: G = __r_arr[3];
+        let __v_24: G = __r_arr[4];
+        let __v_25: G = __r_arr[5];
+        let __v_26: G = __r_arr[6];
+        let __v_27: G = __r_arr[7];
+        let __v_28: G = __r_arr[8];
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __v_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = __r_arr[2];
+        let __v_32: G = __r_arr[3];
+        let __v_33: G = __r_arr[4];
+        let __v_34: G = __r_arr[5];
+        let __v_35: G = __r_arr[6];
+        let __v_36: G = __r_arr[7];
+        let __v_37: G = __r_arr[8];
+        let __v_38: G = G::from_u64(1);
+        let __v_39: G = (__v_1 - __v_38);
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __v_40: G = __r_arr[0];
+        let __v_41: G = __r_arr[1];
+        let __v_42: G = G::from_u64(0);
+        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_105] = [__v_44, __v_41];
+        if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_106: usize = 1;
+const IN_106: usize = 1;
+const OUT_106: usize = 2;
+fn aiur_fn_106(
+  inp: [G; IN_106],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_106], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_106] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_107: usize = 2;
+const IN_107: usize = 2;
+const OUT_107: usize = 2;
+fn aiur_fn_107(
+  inp: [G; IN_107],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_107], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_107] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_107] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_108: usize = 1;
+const IN_108: usize = 1;
+const OUT_108: usize = 2;
+fn aiur_fn_108(
+  inp: [G; IN_108],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_108], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __ret: [G; OUT_108] = [__v_1, __v_2];
+    if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_109: usize = 1;
+const IN_109: usize = 1;
+const OUT_109: usize = 2;
+fn aiur_fn_109(
+  inp: [G; IN_109],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_109], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_109] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_110: usize = 2;
+const IN_110: usize = 2;
+const OUT_110: usize = 2;
+fn aiur_fn_110(
+  inp: [G; IN_110],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_110], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_110] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_110] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_111: usize = 1;
+const IN_111: usize = 1;
+const OUT_111: usize = 3;
+fn aiur_fn_111(
+  inp: [G; IN_111],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_111], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_111] = [__v_3, __v_5, __v_6];
+    if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_112: usize = 1;
+const IN_112: usize = 1;
+const OUT_112: usize = 2;
+fn aiur_fn_112(
+  inp: [G; IN_112],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_112], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_112] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_113: usize = 2;
+const IN_113: usize = 2;
+const OUT_113: usize = 2;
+fn aiur_fn_113(
+  inp: [G; IN_113],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_113], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_113] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_1 - __v_8);
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_113] = [__v_13, __v_11];
+        if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_114: usize = 1;
+const IN_114: usize = 1;
+const OUT_114: usize = 4;
+fn aiur_fn_114(
+  inp: [G; IN_114],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_114], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_114] = [__v_1, __v_3, __v_5, __v_6];
+    if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_115: usize = 1;
+const IN_115: usize = 1;
+const OUT_115: usize = 2;
+fn aiur_fn_115(
+  inp: [G; IN_115],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_115], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_115] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_116: usize = 2;
+const IN_116: usize = 2;
+const OUT_116: usize = 2;
+fn aiur_fn_116(
+  inp: [G; IN_116],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_116], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_116] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_1 - __v_8);
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 5] = [__v_12, __v_2, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_116] = [__v_13, __v_11];
+        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_117: usize = 1;
+const IN_117: usize = 1;
+const OUT_117: usize = 3;
+fn aiur_fn_117(
+  inp: [G; IN_117],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_117], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __ret: [G; OUT_117] = [__v_3, __v_7, __v_8];
+    if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_118: usize = 1;
+const IN_118: usize = 1;
+const OUT_118: usize = 2;
+fn aiur_fn_118(
+  inp: [G; IN_118],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_118], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_118] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_119: usize = 2;
+const IN_119: usize = 2;
+const OUT_119: usize = 2;
+fn aiur_fn_119(
+  inp: [G; IN_119],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_119], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_119] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = (__v_1 - __v_10);
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = { let __values: [G; 4] = [__v_14, __v_4, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_119] = [__v_15, __v_13];
+        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_120: usize = 1;
+const IN_120: usize = 1;
+const OUT_120: usize = 13;
+fn aiur_fn_120(
+  inp: [G; IN_120],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_120], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_12]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __v_15: G = __r_arr[2];
+    let __v_16: G = __r_arr[3];
+    let __v_17: G = __r_arr[4];
+    let __v_18: G = __r_arr[5];
+    let __v_19: G = __r_arr[6];
+    let __v_20: G = __r_arr[7];
+    let __v_21: G = __r_arr[8];
+    let __ret: [G; OUT_120] = [__v_3, __v_5, __v_9, __v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+    if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_121: usize = 1;
+const IN_121: usize = 1;
+const OUT_121: usize = 33;
+fn aiur_fn_121(
+  inp: [G; IN_121],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_121], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __v_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __v_21: G = __r_arr[2];
+    let __v_22: G = __r_arr[3];
+    let __v_23: G = __r_arr[4];
+    let __v_24: G = __r_arr[5];
+    let __v_25: G = __r_arr[6];
+    let __v_26: G = __r_arr[7];
+    let __v_27: G = __r_arr[8];
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __v_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __v_30: G = __r_arr[2];
+    let __v_31: G = __r_arr[3];
+    let __v_32: G = __r_arr[4];
+    let __v_33: G = __r_arr[5];
+    let __v_34: G = __r_arr[6];
+    let __v_35: G = __r_arr[7];
+    let __v_36: G = __r_arr[8];
+    let __ret: [G; OUT_121] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_122: usize = 2;
+const IN_122: usize = 2;
+const OUT_122: usize = 2;
+fn aiur_fn_122(
+  inp: [G; IN_122],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_122], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_122] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = __r_arr[2];
+        let __v_14: G = __r_arr[3];
+        let __v_15: G = __r_arr[4];
+        let __v_16: G = __r_arr[5];
+        let __v_17: G = __r_arr[6];
+        let __v_18: G = __r_arr[7];
+        let __v_19: G = __r_arr[8];
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __v_21: G = __r_arr[1];
+        let __v_22: G = __r_arr[2];
+        let __v_23: G = __r_arr[3];
+        let __v_24: G = __r_arr[4];
+        let __v_25: G = __r_arr[5];
+        let __v_26: G = __r_arr[6];
+        let __v_27: G = __r_arr[7];
+        let __v_28: G = __r_arr[8];
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __v_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = __r_arr[2];
+        let __v_32: G = __r_arr[3];
+        let __v_33: G = __r_arr[4];
+        let __v_34: G = __r_arr[5];
+        let __v_35: G = __r_arr[6];
+        let __v_36: G = __r_arr[7];
+        let __v_37: G = __r_arr[8];
+        let __v_38: G = G::from_u64(1);
+        let __v_39: G = (__v_1 - __v_38);
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __v_40: G = __r_arr[0];
+        let __v_41: G = __r_arr[1];
+        let __v_42: G = G::from_u64(0);
+        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_122] = [__v_44, __v_41];
+        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_123: usize = 1;
+const IN_123: usize = 1;
+const OUT_123: usize = 2;
+fn aiur_fn_123(
+  inp: [G; IN_123],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_123], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_123] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_124: usize = 1;
+const IN_124: usize = 1;
+const OUT_124: usize = 9;
+fn aiur_fn_124(
+  inp: [G; IN_124],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_124], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = __r_arr[2];
+    let __v_14: G = __r_arr[3];
+    let __v_15: G = __r_arr[4];
+    let __v_16: G = __r_arr[5];
+    let __v_17: G = __r_arr[6];
+    let __v_18: G = __r_arr[7];
+    let __v_19: G = __r_arr[8];
+    let __v_20: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __v_23: G = __r_arr[2];
+    let __v_24: G = __r_arr[3];
+    let __v_25: G = __r_arr[4];
+    let __v_26: G = __r_arr[5];
+    let __v_27: G = __r_arr[6];
+    let __v_28: G = __r_arr[7];
+    let __v_29: G = __r_arr[8];
+    let __v_30: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __v_33: G = __r_arr[2];
+    let __v_34: G = __r_arr[3];
+    let __v_35: G = __r_arr[4];
+    let __v_36: G = __r_arr[5];
+    let __v_37: G = __r_arr[6];
+    let __v_38: G = __r_arr[7];
+    let __v_39: G = __r_arr[8];
+    let __v_40: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __v_43: G = __r_arr[2];
+    let __v_44: G = __r_arr[3];
+    let __v_45: G = __r_arr[4];
+    let __v_46: G = __r_arr[5];
+    let __v_47: G = __r_arr[6];
+    let __v_48: G = __r_arr[7];
+    let __v_49: G = __r_arr[8];
+    let __v_50: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __v_53: G = __r_arr[2];
+    let __v_54: G = __r_arr[3];
+    let __v_55: G = __r_arr[4];
+    let __v_56: G = __r_arr[5];
+    let __v_57: G = __r_arr[6];
+    let __v_58: G = __r_arr[7];
+    let __v_59: G = __r_arr[8];
+    let __v_60: G = __r_arr[9];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __v_61: G = __r_arr[0];
+    let __v_62: G = __r_arr[1];
+    let __v_63: G = __r_arr[2];
+    let __v_64: G = __r_arr[3];
+    let __v_65: G = __r_arr[4];
+    let __v_66: G = __r_arr[5];
+    let __v_67: G = __r_arr[6];
+    let __v_68: G = __r_arr[7];
+    let __v_69: G = __r_arr[8];
+    let __v_70: G = __r_arr[9];
+    let __v_71: G = G::from_u64(0);
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = G::from_u64(0);
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = G::from_u64(0);
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = G::from_u64(0);
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = G::from_u64(1);
+    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_124] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70];
+    if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_125: usize = 5;
+const IN_125: usize = 5;
+const OUT_125: usize = 1;
+fn aiur_fn_125(
+  inp: [G; IN_125],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_125], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_125] = [__v_12];
+    if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_126: usize = 33;
+const IN_126: usize = 33;
+const OUT_126: usize = 1;
+fn aiur_fn_126(
+  inp: [G; IN_126],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_126], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __v_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __v_34: G = __r_arr[0];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __v_35: G = __r_arr[0];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __v_36: G = __r_arr[0];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __v_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __v_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __v_39: G = __r_arr[0];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __v_40: G = __r_arr[0];
+    let __ret: [G; OUT_126] = [__v_40];
+    if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_127: usize = 32;
+const IN_127: usize = 32;
+const OUT_127: usize = 32;
+fn aiur_fn_127(
+  inp: [G; IN_127],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_127], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __ret: [G; OUT_127] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31];
+    if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_128: usize = 2;
+const IN_128: usize = 2;
+const OUT_128: usize = 1;
+fn aiur_fn_128(
+  inp: [G; IN_128],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_128], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(103);
+    let __v_3: G = G::from_u64(230);
+    let __v_4: G = G::from_u64(9);
+    let __v_5: G = G::from_u64(106);
+    let __v_6: G = G::from_u64(133);
+    let __v_7: G = G::from_u64(174);
+    let __v_8: G = G::from_u64(103);
+    let __v_9: G = G::from_u64(187);
+    let __v_10: G = G::from_u64(114);
+    let __v_11: G = G::from_u64(243);
+    let __v_12: G = G::from_u64(110);
+    let __v_13: G = G::from_u64(60);
+    let __v_14: G = G::from_u64(58);
+    let __v_15: G = G::from_u64(245);
+    let __v_16: G = G::from_u64(79);
+    let __v_17: G = G::from_u64(165);
+    let __v_18: G = G::from_u64(127);
+    let __v_19: G = G::from_u64(82);
+    let __v_20: G = G::from_u64(14);
+    let __v_21: G = G::from_u64(81);
+    let __v_22: G = G::from_u64(140);
+    let __v_23: G = G::from_u64(104);
+    let __v_24: G = G::from_u64(5);
+    let __v_25: G = G::from_u64(155);
+    let __v_26: G = G::from_u64(171);
+    let __v_27: G = G::from_u64(217);
+    let __v_28: G = G::from_u64(131);
+    let __v_29: G = G::from_u64(31);
+    let __v_30: G = G::from_u64(25);
+    let __v_31: G = G::from_u64(205);
+    let __v_32: G = G::from_u64(224);
+    let __v_33: G = G::from_u64(91);
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_66: G = __loaded[0];
+    let __v_67: G = __loaded[1];
+    let __v_68: G = __loaded[2];
+    let __v_69: G = __loaded[3];
+    let __v_70: G = __loaded[4];
+    let __v_71: G = __loaded[5];
+    let __v_72: G = __loaded[6];
+    let __v_73: G = __loaded[7];
+    let __v_74: G = __loaded[8];
+    let __v_75: G = __loaded[9];
+    let __v_76: G = __loaded[10];
+    let __v_77: G = __loaded[11];
+    let __v_78: G = __loaded[12];
+    let __v_79: G = __loaded[13];
+    let __v_80: G = __loaded[14];
+    let __v_81: G = __loaded[15];
+    let __v_82: G = __loaded[16];
+    let __v_83: G = __loaded[17];
+    let __v_84: G = __loaded[18];
+    let __v_85: G = __loaded[19];
+    let __v_86: G = __loaded[20];
+    let __v_87: G = __loaded[21];
+    let __v_88: G = __loaded[22];
+    let __v_89: G = __loaded[23];
+    let __v_90: G = __loaded[24];
+    let __v_91: G = __loaded[25];
+    let __v_92: G = __loaded[26];
+    let __v_93: G = __loaded[27];
+    let __v_94: G = __loaded[28];
+    let __v_95: G = __loaded[29];
+    let __v_96: G = __loaded[30];
+    let __v_97: G = __loaded[31];
+    let __v_98: G = G::from_u64(0);
+    let __v_99: G = G::from_u64(0);
+    let __v_100: G = G::from_u64(0);
+    let __v_101: G = G::from_u64(0);
+    let __v_102: G = G::from_u64(0);
+    let __v_103: G = G::from_u64(0);
+    let __v_104: G = G::from_u64(0);
+    let __v_105: G = G::from_u64(0);
+    let __v_106: G = G::from_u64(64);
+    let __v_107: G = G::from_u64(11);
+    let __v_108: G = G::from_u64(103);
+    let __v_109: G = G::from_u64(230);
+    let __v_110: G = G::from_u64(9);
+    let __v_111: G = G::from_u64(106);
+    let __v_112: G = G::from_u64(133);
+    let __v_113: G = G::from_u64(174);
+    let __v_114: G = G::from_u64(103);
+    let __v_115: G = G::from_u64(187);
+    let __v_116: G = G::from_u64(114);
+    let __v_117: G = G::from_u64(243);
+    let __v_118: G = G::from_u64(110);
+    let __v_119: G = G::from_u64(60);
+    let __v_120: G = G::from_u64(58);
+    let __v_121: G = G::from_u64(245);
+    let __v_122: G = G::from_u64(79);
+    let __v_123: G = G::from_u64(165);
+    let __v_124: G = G::from_u64(0);
+    let __v_125: G = G::from_u64(0);
+    let __v_126: G = G::from_u64(0);
+    let __v_127: G = G::from_u64(0);
+    let __v_128: G = G::from_u64(0);
+    let __v_129: G = G::from_u64(0);
+    let __v_130: G = G::from_u64(0);
+    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_130, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_124, __v_125, __v_126, __v_107, __v_127, __v_128, __v_129, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+    let __v_131: G = __r_arr[0];
+    let __v_132: G = __r_arr[1];
+    let __v_133: G = __r_arr[2];
+    let __v_134: G = __r_arr[3];
+    let __v_135: G = __r_arr[4];
+    let __v_136: G = __r_arr[5];
+    let __v_137: G = __r_arr[6];
+    let __v_138: G = __r_arr[7];
+    let __v_139: G = __r_arr[8];
+    let __v_140: G = __r_arr[9];
+    let __v_141: G = __r_arr[10];
+    let __v_142: G = __r_arr[11];
+    let __v_143: G = __r_arr[12];
+    let __v_144: G = __r_arr[13];
+    let __v_145: G = __r_arr[14];
+    let __v_146: G = __r_arr[15];
+    let __v_147: G = __r_arr[16];
+    let __v_148: G = __r_arr[17];
+    let __v_149: G = __r_arr[18];
+    let __v_150: G = __r_arr[19];
+    let __v_151: G = __r_arr[20];
+    let __v_152: G = __r_arr[21];
+    let __v_153: G = __r_arr[22];
+    let __v_154: G = __r_arr[23];
+    let __v_155: G = __r_arr[24];
+    let __v_156: G = __r_arr[25];
+    let __v_157: G = __r_arr[26];
+    let __v_158: G = __r_arr[27];
+    let __v_159: G = __r_arr[28];
+    let __v_160: G = __r_arr[29];
+    let __v_161: G = __r_arr[30];
+    let __v_162: G = __r_arr[31];
+    let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_128] = [__v_163];
+    if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_129: usize = 3;
+const IN_129: usize = 3;
+const OUT_129: usize = 1;
+fn aiur_fn_129(
+  inp: [G; IN_129],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_129], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __ret: [G; OUT_129] = [__v_3];
+        if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __ret: [G; OUT_129] = [__v_3];
+        if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_130: usize = 2;
+const IN_130: usize = 2;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_130], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_130] = [__v_5];
+        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = (__v_3 - __v_1);
+        let __v_6: G = G::from_bool((__v_5 == G::ZERO));
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_130] = [__v_7];
+            if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_130] = [__v_7];
+            if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_131: usize = 3;
+const IN_131: usize = 3;
+const OUT_131: usize = 1;
+fn aiur_fn_131(
+  inp: [G; IN_131],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_131], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_131] = [__v_8];
+        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          0u64 => {
+            let __v_9: G = (__v_7 - __v_2);
+            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_131] = [__v_11];
+                if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+                let __v_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                let __v_14: G = __loaded[3];
+                let __v_15: G = __loaded[4];
+                let __v_16: G = __loaded[5];
+                let __v_17: G = __loaded[6];
+                let __v_18: G = __loaded[7];
+                let __v_19: G = __loaded[8];
+                let __v_20: G = __loaded[9];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+                    let __v_21: G = __r_arr[0];
+                    let __ret: [G; OUT_131] = [__v_21];
+                    if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_21: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+                    let __v_22: G = __r_arr[0];
+                    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_131] = [__v_23];
+                    if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_132: usize = 2;
+const IN_132: usize = 2;
+const OUT_132: usize = 11;
+fn aiur_fn_132(
+  inp: [G; IN_132],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_132], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_12: G = G::from_u64(256);
+        let __v_13: G = (__v_12 * __v_4);
+        let __v_14: G = G::from_u64(65536);
+        let __v_15: G = (__v_14 * __v_5);
+        let __v_16: G = G::from_u64(16777216);
+        let __v_17: G = (__v_16 * __v_6);
+        let __v_18: G = G::from_u64(4294967296);
+        let __v_19: G = (__v_18 * __v_7);
+        let __v_20: G = G::from_u64(1099511627776);
+        let __v_21: G = (__v_20 * __v_8);
+        let __v_22: G = G::from_u64(281474976710656);
+        let __v_23: G = (__v_22 * __v_9);
+        let __v_24: G = G::from_u64(72057594037927936);
+        let __v_25: G = (__v_24 * __v_10);
+        let __v_26: G = (__v_23 + __v_25);
+        let __v_27: G = (__v_21 + __v_26);
+        let __v_28: G = (__v_19 + __v_27);
+        let __v_29: G = (__v_17 + __v_28);
+        let __v_30: G = (__v_15 + __v_29);
+        let __v_31: G = (__v_13 + __v_30);
+        let __v_32: G = (__v_3 + __v_31);
+        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
+        let __v_33: G = G::from_u8(__gb[0]);
+        let __v_34: G = G::from_u8(__gb[1]);
+        let __v_35: G = G::from_u8(__gb[2]);
+        let __v_36: G = G::from_u8(__gb[3]);
+        let __v_37: G = G::from_u8(__gb[4]);
+        let __v_38: G = G::from_u8(__gb[5]);
+        let __v_39: G = G::from_u8(__gb[6]);
+        let __v_40: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_41: G = G::from_u64(1020);
+        let __v_42: G = (__v_40 - __v_41);
+        let __v_43: G = (__v_39 + __v_42);
+        let __v_44: G = (__v_38 + __v_43);
+        let __v_45: G = (__v_37 + __v_44);
+        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
+        let __v_47: G = (__v_35 + __v_36);
+        let __v_48: G = (__v_34 + __v_47);
+        let __v_49: G = (__v_33 + __v_48);
+        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
+        let __v_51: G = G::from_u64(256);
+        let __v_52: G = (__v_51 * __v_34);
+        let __v_53: G = G::from_u64(65536);
+        let __v_54: G = (__v_53 * __v_35);
+        let __v_55: G = G::from_u64(16777216);
+        let __v_56: G = (__v_55 * __v_36);
+        let __v_57: G = G::from_u64(4294967296);
+        let __v_58: G = (__v_57 * __v_37);
+        let __v_59: G = G::from_u64(1099511627776);
+        let __v_60: G = (__v_59 * __v_38);
+        let __v_61: G = G::from_u64(281474976710656);
+        let __v_62: G = (__v_61 * __v_39);
+        let __v_63: G = G::from_u64(72057594037927936);
+        let __v_64: G = (__v_63 * __v_40);
+        let __v_65: G = (__v_62 + __v_64);
+        let __v_66: G = (__v_60 + __v_65);
+        let __v_67: G = (__v_58 + __v_66);
+        let __v_68: G = (__v_56 + __v_67);
+        let __v_69: G = (__v_54 + __v_68);
+        let __v_70: G = (__v_52 + __v_69);
+        let __v_71: G = (__v_33 + __v_70);
+        if (__v_71 != __v_32) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+        }
+        let __v_72: G = G::from_u64(1);
+        let __v_73: G = G::from_u64(1);
+        let __v_74: G = (__v_73 - __v_50);
+        let __v_75: G = (__v_46 * __v_74);
+        let __v_76: G = (__v_72 - __v_75);
+        let __v_77: G = G::from_u64(1);
+        if (__v_76 != __v_77) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
+        }
+        let __v_78: G = G::from_u64(1);
+        let __ret: [G; OUT_132] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78];
+        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = G::from_u64(0);
+            let __v_19: G = G::from_u64(0);
+            let __v_20: G = G::from_u64(0);
+            let __v_21: G = G::from_u64(0);
+            let __v_22: G = G::from_u64(0);
+            let __v_23: G = G::from_u64(0);
+            let __ret: [G; OUT_132] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
+            if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __v_16: G = __r_arr[1];
+            let __v_17: G = __r_arr[2];
+            let __v_18: G = __r_arr[3];
+            let __v_19: G = __r_arr[4];
+            let __v_20: G = __r_arr[5];
+            let __v_21: G = __r_arr[6];
+            let __v_22: G = __r_arr[7];
+            let __v_23: G = __r_arr[8];
+            let __v_24: G = __r_arr[9];
+            let __v_25: G = __r_arr[10];
+            let __ret: [G; OUT_132] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+            if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_133: usize = 6;
+const IN_133: usize = 6;
+const OUT_133: usize = 1;
+fn aiur_fn_133(
+  inp: [G; IN_133],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_133], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __v_8: G = __r_arr[2];
+    let __v_9: G = __r_arr[3];
+    let __v_10: G = __r_arr[4];
+    let __v_11: G = __r_arr[5];
+    let __v_12: G = __r_arr[6];
+    let __v_13: G = __r_arr[7];
+    let __v_14: G = __r_arr[8];
+    let __v_15: G = __r_arr[9];
+    let __v_16: G = __r_arr[10];
+    match __v_16.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_17: G = __loaded[0];
+        let __v_18: G = __loaded[1];
+        let __v_19: G = __loaded[2];
+        let __v_20: G = __loaded[3];
+        let __v_21: G = __loaded[4];
+        let __v_22: G = __loaded[5];
+        let __v_23: G = __loaded[6];
+        let __v_24: G = __loaded[7];
+        match __v_17.as_canonical_u64() {
+          0u64 => {
+            match __v_18.as_canonical_u64() {
+              0u64 => {
+                match __v_19.as_canonical_u64() {
+                  0u64 => {
+                    match __v_20.as_canonical_u64() {
+                      0u64 => {
+                        match __v_21.as_canonical_u64() {
+                          0u64 => {
+                            match __v_22.as_canonical_u64() {
+                              0u64 => {
+                                match __v_23.as_canonical_u64() {
+                                  0u64 => {
+                                    match __v_24.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                        let __v_25: G = __loaded[0];
+                                        let __v_26: G = __loaded[1];
+                                        let __v_27: G = __loaded[2];
+                                        let __v_28: G = __loaded[3];
+                                        let __v_29: G = __loaded[4];
+                                        let __v_30: G = __loaded[5];
+                                        let __v_31: G = __loaded[6];
+                                        let __v_32: G = __loaded[7];
+                                        let __v_33: G = __loaded[8];
+                                        let __v_34: G = __loaded[9];
+                                        let __v_35: G = __loaded[10];
+                                        let __v_36: G = __loaded[11];
+                                        let __v_37: G = __loaded[12];
+                                        let __v_38: G = __loaded[13];
+                                        let __v_39: G = __loaded[14];
+                                        let __v_40: G = __loaded[15];
+                                        let __v_41: G = __loaded[16];
+                                        let __v_42: G = __loaded[17];
+                                        let __v_43: G = __loaded[18];
+                                        let __v_44: G = __loaded[19];
+                                        let __v_45: G = __loaded[20];
+                                        let __v_46: G = __loaded[21];
+                                        let __v_47: G = __loaded[22];
+                                        let __v_48: G = __loaded[23];
+                                        let __v_49: G = __loaded[24];
+                                        let __v_50: G = __loaded[25];
+                                        let __v_51: G = __loaded[26];
+                                        let __v_52: G = __loaded[27];
+                                        let __v_53: G = __loaded[28];
+                                        let __v_54: G = __loaded[29];
+                                        let __v_55: G = __loaded[30];
+                                        let __v_56: G = __loaded[31];
+                                        let __v_57: G = G::from_u64(0);
+                                        let __v_58: G = G::from_u64(0);
+                                        let __v_59: G = G::from_u64(0);
+                                        let __v_60: G = G::from_u64(0);
+                                        let __v_61: G = G::from_u64(0);
+                                        let __v_62: G = G::from_u64(0);
+                                        let __v_63: G = G::from_u64(0);
+                                        let __v_64: G = G::from_u64(0);
+                                        let __v_65: G = G::from_u64(0);
+                                        let __v_66: G = G::from_u64(0);
+                                        let __v_67: G = G::from_u64(0);
+                                        let __v_68: G = G::from_u64(0);
+                                        let __v_69: G = G::from_u64(0);
+                                        let __v_70: G = G::from_u64(0);
+                                        let __v_71: G = G::from_u64(0);
+                                        let __v_72: G = G::from_u64(0);
+                                        let __v_73: G = G::from_u64(0);
+                                        let __v_74: G = G::from_u64(0);
+                                        let __v_75: G = G::from_u64(0);
+                                        let __v_76: G = G::from_u64(0);
+                                        let __v_77: G = G::from_u64(0);
+                                        let __v_78: G = G::from_u64(0);
+                                        let __v_79: G = G::from_u64(0);
+                                        let __v_80: G = G::from_u64(0);
+                                        let __v_81: G = G::from_u64(0);
+                                        let __v_82: G = G::from_u64(0);
+                                        let __v_83: G = G::from_u64(0);
+                                        let __v_84: G = G::from_u64(0);
+                                        let __v_85: G = G::from_u64(0);
+                                        let __v_86: G = G::from_u64(0);
+                                        let __v_87: G = G::from_u64(0);
+                                        let __v_88: G = G::from_u64(0);
+                                        let __v_89: G = G::from_u64(0);
+                                        let __v_90: G = G::from_u64(0);
+                                        let __v_91: G = G::from_u64(0);
+                                        let __v_92: G = G::from_u64(0);
+                                        let __v_93: G = G::from_u64(0);
+                                        let __v_94: G = G::from_u64(0);
+                                        let __v_95: G = G::from_u64(0);
+                                        let __v_96: G = G::from_u64(0);
+                                        let __v_97: G = G::from_u64(0);
+                                        let __v_98: G = G::from_u64(0);
+                                        let __v_99: G = G::from_u64(0);
+                                        let __v_100: G = G::from_u64(0);
+                                        let __v_101: G = G::from_u64(0);
+                                        let __v_102: G = G::from_u64(0);
+                                        let __v_103: G = G::from_u64(0);
+                                        let __v_104: G = G::from_u64(0);
+                                        let __v_105: G = G::from_u64(0);
+                                        let __v_106: G = G::from_u64(0);
+                                        let __v_107: G = G::from_u64(0);
+                                        let __v_108: G = G::from_u64(0);
+                                        let __v_109: G = G::from_u64(0);
+                                        let __v_110: G = G::from_u64(0);
+                                        let __v_111: G = G::from_u64(0);
+                                        let __v_112: G = G::from_u64(0);
+                                        let __v_113: G = G::from_u64(0);
+                                        let __v_114: G = G::from_u64(0);
+                                        let __v_115: G = G::from_u64(0);
+                                        let __v_116: G = G::from_u64(0);
+                                        let __v_117: G = G::from_u64(0);
+                                        let __v_118: G = G::from_u64(0);
+                                        let __v_119: G = G::from_u64(0);
+                                        let __v_120: G = G::from_u64(0);
+                                        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                        let __v_121: G = __loaded[0];
+                                        let __v_122: G = __loaded[1];
+                                        let __v_123: G = __loaded[2];
+                                        let __v_124: G = __loaded[3];
+                                        let __v_125: G = __loaded[4];
+                                        let __v_126: G = __loaded[5];
+                                        let __v_127: G = __loaded[6];
+                                        let __v_128: G = __loaded[7];
+                                        let __v_129: G = G::from_u64(0);
+                                        let __v_130: G = G::from_u64(11);
+                                        let __v_131: G = G::from_u64(103);
+                                        let __v_132: G = G::from_u64(230);
+                                        let __v_133: G = G::from_u64(9);
+                                        let __v_134: G = G::from_u64(106);
+                                        let __v_135: G = G::from_u64(133);
+                                        let __v_136: G = G::from_u64(174);
+                                        let __v_137: G = G::from_u64(103);
+                                        let __v_138: G = G::from_u64(187);
+                                        let __v_139: G = G::from_u64(114);
+                                        let __v_140: G = G::from_u64(243);
+                                        let __v_141: G = G::from_u64(110);
+                                        let __v_142: G = G::from_u64(60);
+                                        let __v_143: G = G::from_u64(58);
+                                        let __v_144: G = G::from_u64(245);
+                                        let __v_145: G = G::from_u64(79);
+                                        let __v_146: G = G::from_u64(165);
+                                        let __v_147: G = G::from_u64(0);
+                                        let __v_148: G = G::from_u64(0);
+                                        let __v_149: G = G::from_u64(0);
+                                        let __v_150: G = G::from_u64(0);
+                                        let __v_151: G = G::from_u64(0);
+                                        let __v_152: G = G::from_u64(0);
+                                        let __v_153: G = G::from_u64(0);
+                                        let __v_154: G = G::from_u64(0);
+                                        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_154, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_147, __v_148, __v_149, __v_130, __v_150, __v_151, __v_152, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+                                        let __v_155: G = __r_arr[0];
+                                        let __v_156: G = __r_arr[1];
+                                        let __v_157: G = __r_arr[2];
+                                        let __v_158: G = __r_arr[3];
+                                        let __v_159: G = __r_arr[4];
+                                        let __v_160: G = __r_arr[5];
+                                        let __v_161: G = __r_arr[6];
+                                        let __v_162: G = __r_arr[7];
+                                        let __v_163: G = __r_arr[8];
+                                        let __v_164: G = __r_arr[9];
+                                        let __v_165: G = __r_arr[10];
+                                        let __v_166: G = __r_arr[11];
+                                        let __v_167: G = __r_arr[12];
+                                        let __v_168: G = __r_arr[13];
+                                        let __v_169: G = __r_arr[14];
+                                        let __v_170: G = __r_arr[15];
+                                        let __v_171: G = __r_arr[16];
+                                        let __v_172: G = __r_arr[17];
+                                        let __v_173: G = __r_arr[18];
+                                        let __v_174: G = __r_arr[19];
+                                        let __v_175: G = __r_arr[20];
+                                        let __v_176: G = __r_arr[21];
+                                        let __v_177: G = __r_arr[22];
+                                        let __v_178: G = __r_arr[23];
+                                        let __v_179: G = __r_arr[24];
+                                        let __v_180: G = __r_arr[25];
+                                        let __v_181: G = __r_arr[26];
+                                        let __v_182: G = __r_arr[27];
+                                        let __v_183: G = __r_arr[28];
+                                        let __v_184: G = __r_arr[29];
+                                        let __v_185: G = __r_arr[30];
+                                        let __v_186: G = __r_arr[31];
+                                        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_133] = [__v_187];
+                                        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_133] = [__v_5];
+                                        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_133] = [__v_5];
+                                    if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_133] = [__v_5];
+                                if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_133] = [__v_5];
+                            if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __ret: [G; OUT_133] = [__v_5];
+                        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __ret: [G; OUT_133] = [__v_5];
+                    if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_133] = [__v_5];
+                if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __ret: [G; OUT_133] = [__v_5];
+            if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __v_18: G = __r_arr[1];
+        let __v_19: G = __r_arr[2];
+        let __v_20: G = __r_arr[3];
+        let __v_21: G = __r_arr[4];
+        let __v_22: G = __r_arr[5];
+        let __v_23: G = __r_arr[6];
+        let __v_24: G = __r_arr[7];
+        let __v_25: G = __r_arr[8];
+        let __v_26: G = __r_arr[9];
+        let __v_27: G = __r_arr[10];
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __v_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        let __v_30: G = __r_arr[2];
+        let __v_31: G = __r_arr[3];
+        let __v_32: G = __r_arr[4];
+        let __v_33: G = __r_arr[5];
+        let __v_34: G = __r_arr[6];
+        let __v_35: G = __r_arr[7];
+        let __v_36: G = __r_arr[8];
+        let __v_37: G = __r_arr[9];
+        let __v_38: G = __r_arr[10];
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __v_39: G = __r_arr[0];
+        let __v_40: G = __r_arr[1];
+        let __v_41: G = __r_arr[2];
+        let __v_42: G = __r_arr[3];
+        let __v_43: G = __r_arr[4];
+        let __v_44: G = __r_arr[5];
+        let __v_45: G = __r_arr[6];
+        let __v_46: G = __r_arr[7];
+        let __v_47: G = __r_arr[8];
+        let __v_48: G = __r_arr[9];
+        let __v_49: G = __r_arr[10];
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __v_50: G = __r_arr[0];
+        let __v_51: G = __r_arr[1];
+        let __v_52: G = __r_arr[2];
+        let __v_53: G = __r_arr[3];
+        let __v_54: G = __r_arr[4];
+        let __v_55: G = __r_arr[5];
+        let __v_56: G = __r_arr[6];
+        let __v_57: G = __r_arr[7];
+        let __v_58: G = __r_arr[8];
+        let __v_59: G = __r_arr[9];
+        let __v_60: G = __r_arr[10];
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __v_61: G = __r_arr[0];
+        let __v_62: G = __r_arr[1];
+        let __v_63: G = __r_arr[2];
+        let __v_64: G = __r_arr[3];
+        let __v_65: G = __r_arr[4];
+        let __v_66: G = __r_arr[5];
+        let __v_67: G = __r_arr[6];
+        let __v_68: G = __r_arr[7];
+        let __v_69: G = __r_arr[8];
+        let __v_70: G = __r_arr[9];
+        let __v_71: G = __r_arr[10];
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __v_72: G = __r_arr[0];
+        let __v_73: G = __r_arr[1];
+        let __v_74: G = __r_arr[2];
+        let __v_75: G = __r_arr[3];
+        let __v_76: G = __r_arr[4];
+        let __v_77: G = __r_arr[5];
+        let __v_78: G = __r_arr[6];
+        let __v_79: G = __r_arr[7];
+        let __v_80: G = __r_arr[8];
+        let __v_81: G = __r_arr[9];
+        let __v_82: G = __r_arr[10];
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __v_83: G = __r_arr[0];
+        let __v_84: G = __r_arr[1];
+        let __v_85: G = __r_arr[2];
+        let __v_86: G = __r_arr[3];
+        let __v_87: G = __r_arr[4];
+        let __v_88: G = __r_arr[5];
+        let __v_89: G = __r_arr[6];
+        let __v_90: G = __r_arr[7];
+        let __v_91: G = __r_arr[8];
+        let __v_92: G = __r_arr[9];
+        let __v_93: G = __r_arr[10];
+        let __v_94: G = G::from_u64(8);
+        let __v_95: G = (__v_82 + __v_93);
+        let __v_96: G = (__v_71 + __v_95);
+        let __v_97: G = (__v_60 + __v_96);
+        let __v_98: G = (__v_49 + __v_97);
+        let __v_99: G = (__v_38 + __v_98);
+        let __v_100: G = (__v_27 + __v_99);
+        let __v_101: G = (__v_16 + __v_100);
+        let __v_102: G = (__v_94 * __v_101);
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_103: G = __loaded[0];
+        let __v_104: G = __loaded[1];
+        let __v_105: G = __loaded[2];
+        let __v_106: G = __loaded[3];
+        let __v_107: G = __loaded[4];
+        let __v_108: G = __loaded[5];
+        let __v_109: G = __loaded[6];
+        let __v_110: G = __loaded[7];
+        let __v_111: G = __loaded[8];
+        let __v_112: G = __loaded[9];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() {
+  1u64 => {
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_113: G = __loaded[0];
+    let __v_114: G = __loaded[1];
+    let __v_115: G = __loaded[2];
+    match __v_113.as_canonical_u64() {
+      1u64 => {
+        let __v_116: G = G::from_u64(1);
+        break '__mc_0 [__v_116];
+      },
+      _ => {
+        let __v_116: G = G::from_u64(0);
+        break '__mc_0 [__v_116];
+      },
+    }
+  },
+  _ => {
+    let __v_113: G = G::from_u64(0);
+    break '__mc_0 [__v_113];
+  },
+}
+ };
+        let __v_113: G = __mc_out___mc_0[0];
+        let __v_114: G = G::from_u64(15);
+        let __v_115: G = (__v_2 - __v_114);
+        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
+        let __v_117: G = G::from_bool((__v_2 == G::ZERO));
+        let __v_118: G = (__v_113 * __v_116);
+        let __v_119: G = (__v_116 - __v_118);
+        let __v_120: G = (__v_113 + __v_119);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_121: G = __loaded[0];
+        let __v_122: G = __loaded[1];
+        let __v_123: G = __loaded[2];
+        let __v_124: G = __loaded[3];
+        let __v_125: G = __loaded[4];
+        let __v_126: G = __loaded[5];
+        let __v_127: G = __loaded[6];
+        let __v_128: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_129: G = __r_arr[0];
+        let __v_130: G = (__v_113 * __v_129);
+        let __v_131: G = G::from_u64(2);
+        let __v_132: G = (__v_131 * __v_120);
+        let __v_133: G = G::from_u64(8);
+        let __v_134: G = (__v_133 * __v_130);
+        let __v_135: G = (__v_132 + __v_134);
+        let __v_136: G = (__v_117 + __v_135);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_137: G = __loaded[0];
+        let __v_138: G = __loaded[1];
+        let __v_139: G = __loaded[2];
+        let __v_140: G = __loaded[3];
+        let __v_141: G = __loaded[4];
+        let __v_142: G = __loaded[5];
+        let __v_143: G = __loaded[6];
+        let __v_144: G = __loaded[7];
+        let __v_145: G = __loaded[8];
+        let __v_146: G = __loaded[9];
+        let __v_147: G = __loaded[10];
+        let __v_148: G = __loaded[11];
+        let __v_149: G = __loaded[12];
+        let __v_150: G = __loaded[13];
+        let __v_151: G = __loaded[14];
+        let __v_152: G = __loaded[15];
+        let __v_153: G = __loaded[16];
+        let __v_154: G = __loaded[17];
+        let __v_155: G = __loaded[18];
+        let __v_156: G = __loaded[19];
+        let __v_157: G = __loaded[20];
+        let __v_158: G = __loaded[21];
+        let __v_159: G = __loaded[22];
+        let __v_160: G = __loaded[23];
+        let __v_161: G = __loaded[24];
+        let __v_162: G = __loaded[25];
+        let __v_163: G = __loaded[26];
+        let __v_164: G = __loaded[27];
+        let __v_165: G = __loaded[28];
+        let __v_166: G = __loaded[29];
+        let __v_167: G = __loaded[30];
+        let __v_168: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_169: G = __loaded[0];
+        let __v_170: G = __loaded[1];
+        let __v_171: G = __loaded[2];
+        let __v_172: G = __loaded[3];
+        let __v_173: G = __loaded[4];
+        let __v_174: G = __loaded[5];
+        let __v_175: G = __loaded[6];
+        let __v_176: G = __loaded[7];
+        let __v_177: G = G::from_u64(103);
+        let __v_178: G = G::from_u64(230);
+        let __v_179: G = G::from_u64(9);
+        let __v_180: G = G::from_u64(106);
+        let __v_181: G = G::from_u64(133);
+        let __v_182: G = G::from_u64(174);
+        let __v_183: G = G::from_u64(103);
+        let __v_184: G = G::from_u64(187);
+        let __v_185: G = G::from_u64(114);
+        let __v_186: G = G::from_u64(243);
+        let __v_187: G = G::from_u64(110);
+        let __v_188: G = G::from_u64(60);
+        let __v_189: G = G::from_u64(58);
+        let __v_190: G = G::from_u64(245);
+        let __v_191: G = G::from_u64(79);
+        let __v_192: G = G::from_u64(165);
+        let __v_193: G = G::from_u64(0);
+        let __v_194: G = G::from_u64(0);
+        let __v_195: G = G::from_u64(0);
+        let __v_196: G = G::from_u64(0);
+        let __v_197: G = G::from_u64(0);
+        let __v_198: G = G::from_u64(0);
+        let __v_199: G = G::from_u64(0);
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_199, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_193, __v_194, __v_195, __v_136, __v_196, __v_197, __v_198, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __v_200: G = __r_arr[0];
+        let __v_201: G = __r_arr[1];
+        let __v_202: G = __r_arr[2];
+        let __v_203: G = __r_arr[3];
+        let __v_204: G = __r_arr[4];
+        let __v_205: G = __r_arr[5];
+        let __v_206: G = __r_arr[6];
+        let __v_207: G = __r_arr[7];
+        let __v_208: G = __r_arr[8];
+        let __v_209: G = __r_arr[9];
+        let __v_210: G = __r_arr[10];
+        let __v_211: G = __r_arr[11];
+        let __v_212: G = __r_arr[12];
+        let __v_213: G = __r_arr[13];
+        let __v_214: G = __r_arr[14];
+        let __v_215: G = __r_arr[15];
+        let __v_216: G = __r_arr[16];
+        let __v_217: G = __r_arr[17];
+        let __v_218: G = __r_arr[18];
+        let __v_219: G = __r_arr[19];
+        let __v_220: G = __r_arr[20];
+        let __v_221: G = __r_arr[21];
+        let __v_222: G = __r_arr[22];
+        let __v_223: G = __r_arr[23];
+        let __v_224: G = __r_arr[24];
+        let __v_225: G = __r_arr[25];
+        let __v_226: G = __r_arr[26];
+        let __v_227: G = __r_arr[27];
+        let __v_228: G = __r_arr[28];
+        let __v_229: G = __r_arr[29];
+        let __v_230: G = __r_arr[30];
+        let __v_231: G = __r_arr[31];
+        match __v_113.as_canonical_u64() {
+          1u64 => {
+            let __v_232: G = G::from_u64(0);
+            let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_133] = [__v_233];
+            if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            match __v_116.as_canonical_u64() {
+              1u64 => {
+                let __v_232: G = G::from_u64(103);
+                let __v_233: G = G::from_u64(230);
+                let __v_234: G = G::from_u64(9);
+                let __v_235: G = G::from_u64(106);
+                let __v_236: G = G::from_u64(133);
+                let __v_237: G = G::from_u64(174);
+                let __v_238: G = G::from_u64(103);
+                let __v_239: G = G::from_u64(187);
+                let __v_240: G = G::from_u64(114);
+                let __v_241: G = G::from_u64(243);
+                let __v_242: G = G::from_u64(110);
+                let __v_243: G = G::from_u64(60);
+                let __v_244: G = G::from_u64(58);
+                let __v_245: G = G::from_u64(245);
+                let __v_246: G = G::from_u64(79);
+                let __v_247: G = G::from_u64(165);
+                let __v_248: G = G::from_u64(127);
+                let __v_249: G = G::from_u64(82);
+                let __v_250: G = G::from_u64(14);
+                let __v_251: G = G::from_u64(81);
+                let __v_252: G = G::from_u64(140);
+                let __v_253: G = G::from_u64(104);
+                let __v_254: G = G::from_u64(5);
+                let __v_255: G = G::from_u64(155);
+                let __v_256: G = G::from_u64(171);
+                let __v_257: G = G::from_u64(217);
+                let __v_258: G = G::from_u64(131);
+                let __v_259: G = G::from_u64(31);
+                let __v_260: G = G::from_u64(25);
+                let __v_261: G = G::from_u64(205);
+                let __v_262: G = G::from_u64(224);
+                let __v_263: G = G::from_u64(91);
+                let __v_264: G = G::from_u64(0);
+                let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                let __v_265: G = __loaded[0];
+                let __v_266: G = __loaded[1];
+                let __v_267: G = __loaded[2];
+                let __v_268: G = __loaded[3];
+                let __v_269: G = __loaded[4];
+                let __v_270: G = __loaded[5];
+                let __v_271: G = __loaded[6];
+                let __v_272: G = __loaded[7];
+                let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+                let __v_273: G = __r_arr[0];
+                let __v_274: G = __r_arr[1];
+                let __v_275: G = __r_arr[2];
+                let __v_276: G = __r_arr[3];
+                let __v_277: G = __r_arr[4];
+                let __v_278: G = __r_arr[5];
+                let __v_279: G = __r_arr[6];
+                let __v_280: G = __r_arr[7];
+                let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_283: G = G::from_u64(0);
+                let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+                let __v_285: G = __r_arr[0];
+                let __ret: [G; OUT_133] = [__v_285];
+                if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_232: G = G::from_u64(1);
+                let __v_233: G = (__v_2 + __v_232);
+                let __v_234: G = { let __values: [G; 32] = [__v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+                let __v_235: G = __r_arr[0];
+                let __ret: [G; OUT_133] = [__v_235];
+                if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_134: usize = 1;
+const IN_134: usize = 1;
+const OUT_134: usize = 32;
+fn aiur_fn_134(
+  inp: [G; IN_134],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_134], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(103);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(9);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(103);
+    let __v_8: G = G::from_u64(187);
+    let __v_9: G = G::from_u64(114);
+    let __v_10: G = G::from_u64(243);
+    let __v_11: G = G::from_u64(110);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(245);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(165);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(82);
+    let __v_19: G = G::from_u64(14);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(104);
+    let __v_23: G = G::from_u64(5);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(217);
+    let __v_27: G = G::from_u64(131);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(25);
+    let __v_30: G = G::from_u64(205);
+    let __v_31: G = G::from_u64(224);
+    let __v_32: G = G::from_u64(91);
+    let __v_33: G = G::from_u64(1);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __v_50: G = __r_arr[0];
+    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __v_53: G = __r_arr[2];
+    let __v_54: G = __r_arr[3];
+    let __v_55: G = __r_arr[4];
+    let __v_56: G = __r_arr[5];
+    let __v_57: G = __r_arr[6];
+    let __v_58: G = __r_arr[7];
+    let __v_59: G = __r_arr[8];
+    let __v_60: G = __r_arr[9];
+    let __v_61: G = __r_arr[10];
+    let __v_62: G = __r_arr[11];
+    let __v_63: G = __r_arr[12];
+    let __v_64: G = __r_arr[13];
+    let __v_65: G = __r_arr[14];
+    let __v_66: G = __r_arr[15];
+    let __v_67: G = __r_arr[16];
+    let __v_68: G = __r_arr[17];
+    let __v_69: G = __r_arr[18];
+    let __v_70: G = __r_arr[19];
+    let __v_71: G = __r_arr[20];
+    let __v_72: G = __r_arr[21];
+    let __v_73: G = __r_arr[22];
+    let __v_74: G = __r_arr[23];
+    let __v_75: G = __r_arr[24];
+    let __v_76: G = __r_arr[25];
+    let __v_77: G = __r_arr[26];
+    let __v_78: G = __r_arr[27];
+    let __v_79: G = __r_arr[28];
+    let __v_80: G = __r_arr[29];
+    let __v_81: G = __r_arr[30];
+    let __v_82: G = __r_arr[31];
+    let __ret: [G; OUT_134] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82];
+    if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_135: usize = 3;
+const IN_135: usize = 3;
+const OUT_135: usize = 1;
+fn aiur_fn_135(
+  inp: [G; IN_135],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_135], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = G::from_u64(103);
+    let __v_5: G = G::from_u64(230);
+    let __v_6: G = G::from_u64(9);
+    let __v_7: G = G::from_u64(106);
+    let __v_8: G = G::from_u64(133);
+    let __v_9: G = G::from_u64(174);
+    let __v_10: G = G::from_u64(103);
+    let __v_11: G = G::from_u64(187);
+    let __v_12: G = G::from_u64(114);
+    let __v_13: G = G::from_u64(243);
+    let __v_14: G = G::from_u64(110);
+    let __v_15: G = G::from_u64(60);
+    let __v_16: G = G::from_u64(58);
+    let __v_17: G = G::from_u64(245);
+    let __v_18: G = G::from_u64(79);
+    let __v_19: G = G::from_u64(165);
+    let __v_20: G = G::from_u64(127);
+    let __v_21: G = G::from_u64(82);
+    let __v_22: G = G::from_u64(14);
+    let __v_23: G = G::from_u64(81);
+    let __v_24: G = G::from_u64(140);
+    let __v_25: G = G::from_u64(104);
+    let __v_26: G = G::from_u64(5);
+    let __v_27: G = G::from_u64(155);
+    let __v_28: G = G::from_u64(171);
+    let __v_29: G = G::from_u64(217);
+    let __v_30: G = G::from_u64(131);
+    let __v_31: G = G::from_u64(31);
+    let __v_32: G = G::from_u64(25);
+    let __v_33: G = G::from_u64(205);
+    let __v_34: G = G::from_u64(224);
+    let __v_35: G = G::from_u64(91);
+    let __v_36: G = G::from_u64(1);
+    let __v_37: G = G::from_u64(1);
+    let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = G::from_u64(0);
+    let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_50: G = G::from_u64(1);
+    let __v_51: G = G::from_u64(1);
+    let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __v_53: G = __r_arr[0];
+    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __v_54: G = __r_arr[0];
+    let __v_55: G = __r_arr[1];
+    let __v_56: G = __r_arr[2];
+    let __v_57: G = __r_arr[3];
+    let __v_58: G = __r_arr[4];
+    let __v_59: G = __r_arr[5];
+    let __v_60: G = __r_arr[6];
+    let __v_61: G = __r_arr[7];
+    let __v_62: G = __r_arr[8];
+    let __v_63: G = __r_arr[9];
+    let __v_64: G = __r_arr[10];
+    let __v_65: G = __r_arr[11];
+    let __v_66: G = __r_arr[12];
+    let __v_67: G = __r_arr[13];
+    let __v_68: G = __r_arr[14];
+    let __v_69: G = __r_arr[15];
+    let __v_70: G = __r_arr[16];
+    let __v_71: G = __r_arr[17];
+    let __v_72: G = __r_arr[18];
+    let __v_73: G = __r_arr[19];
+    let __v_74: G = __r_arr[20];
+    let __v_75: G = __r_arr[21];
+    let __v_76: G = __r_arr[22];
+    let __v_77: G = __r_arr[23];
+    let __v_78: G = __r_arr[24];
+    let __v_79: G = __r_arr[25];
+    let __v_80: G = __r_arr[26];
+    let __v_81: G = __r_arr[27];
+    let __v_82: G = __r_arr[28];
+    let __v_83: G = __r_arr[29];
+    let __v_84: G = __r_arr[30];
+    let __v_85: G = __r_arr[31];
+    let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_135] = [__v_86];
+    if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_136: usize = 4;
+const IN_136: usize = 4;
+const OUT_136: usize = 1;
+fn aiur_fn_136(
+  inp: [G; IN_136],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_136], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_136] = [__v_3];
+        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_136] = [__v_6];
+        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_137: usize = 1;
+const IN_137: usize = 1;
+const OUT_137: usize = 1;
+fn aiur_fn_137(
+  inp: [G; IN_137],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_137], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_137] = [__v_4];
+        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(2);
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = (__v_4 * __v_5);
+        let __v_7: G = (__v_2 + __v_6);
+        let __ret: [G; OUT_137] = [__v_7];
+        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_138: usize = 6;
+const IN_138: usize = 6;
+const OUT_138: usize = 2;
+fn aiur_fn_138(
+  inp: [G; IN_138],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_138], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    match __v_6.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_138] = [__v_0, __v_9];
+        if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        match __v_9.as_canonical_u64() {
+          0u64 => {
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
+  0u64 => {
+    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    break '__mc_0 [__v_12];
+  },
+  _ => {
+    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_7, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    break '__mc_0 [__v_12];
+  },
+}
+ };
+            let __v_12: G = __mc_out___mc_0[0];
+            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_13.as_canonical_u64() {
+  0u64 => {
+    break '__mc_1 [__v_12];
+  },
+  _ => {
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    break '__mc_1 [__v_15];
+  },
+}
+ };
+            let __v_14: G = __mc_out___mc_1[0];
+            let __v_15: G = G::from_u64(1);
+            let __v_16: G = (__v_5 - __v_15);
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1, __v_2, __v_8, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __v_18: G = __r_arr[1];
+            let __ret: [G; OUT_138] = [__v_17, __v_18];
+            if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_139: usize = 5;
+const IN_139: usize = 5;
+const OUT_139: usize = 2;
+fn aiur_fn_139(
+  inp: [G; IN_139],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_139], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = G::from_u64(1);
+    let __v_7: G = (__v_4 - __v_6);
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_5, __v_0, __v_1, __v_3, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __ret: [G; OUT_139] = [__v_8, __v_9];
+    if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_140: usize = 6;
+const IN_140: usize = 6;
+const OUT_140: usize = 1;
+fn aiur_fn_140(
+  inp: [G; IN_140],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_140], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = G::from_u64(1);
+    let __v_8: G = (__v_5 - __v_7);
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_6, __v_1, __v_2, __v_4, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = (__v_11 - __v_9);
+    let __v_13: G = G::from_bool((__v_12 == G::ZERO));
+    let __ret: [G; OUT_140] = [__v_13];
+    if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_141: usize = 2;
+const IN_141: usize = 2;
+const OUT_141: usize = 1;
+fn aiur_fn_141(
+  inp: [G; IN_141],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_141], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_141] = [__v_5];
+        if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = (__v_0 * __v_0);
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_141] = [__v_6];
+            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_7: G = (__v_0 * __v_6);
+            let __ret: [G; OUT_141] = [__v_7];
+            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_142: usize = 8;
+const IN_142: usize = 8;
+const OUT_142: usize = 2;
+fn aiur_fn_142(
+  inp: [G; IN_142],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_142], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(1);
+    let __v_9: G = (__v_1 + __v_8);
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = G::from_u64(1);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = (__v_15 + __v_15);
+    let __v_17: G = (__v_4 + __v_6);
+    let __v_18: G = (__v_5 + __v_7);
+    let __v_19: G = G::from_u64(2);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = (__v_19 * __v_19);
+    let __v_22: G = G::from_u64(7);
+    let __v_23: G = (__v_20 * __v_20);
+    let __v_24: G = (__v_22 * __v_23);
+    let __v_25: G = (__v_21 - __v_24);
+    let __v_26: G = g_inverse_value(__v_25);
+    let __v_27: G = (__v_25 * __v_26);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = (__v_27 - __v_28);
+    let __v_30: G = (__v_25 * __v_29);
+    let __v_31: G = G::from_u64(0);
+    if (__v_30 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+    }
+    let __v_32: G = (__v_26 * __v_29);
+    let __v_33: G = G::from_u64(0);
+    if (__v_32 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
+    }
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = (__v_34 - __v_20);
+    let __v_36: G = (__v_19 * __v_26);
+    let __v_37: G = (__v_35 * __v_26);
+    let __v_38: G = (__v_17 * __v_36);
+    let __v_39: G = G::from_u64(7);
+    let __v_40: G = (__v_18 * __v_37);
+    let __v_41: G = (__v_39 * __v_40);
+    let __v_42: G = (__v_17 * __v_37);
+    let __v_43: G = (__v_18 * __v_36);
+    let __v_44: G = (__v_38 + __v_41);
+    let __v_45: G = (__v_42 + __v_43);
+    let __v_46: G = (__v_4 - __v_6);
+    let __v_47: G = (__v_5 - __v_7);
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = (__v_16 * __v_16);
+    let __v_50: G = G::from_u64(7);
+    let __v_51: G = (__v_48 * __v_48);
+    let __v_52: G = (__v_50 * __v_51);
+    let __v_53: G = (__v_49 - __v_52);
+    let __v_54: G = g_inverse_value(__v_53);
+    let __v_55: G = (__v_53 * __v_54);
+    let __v_56: G = G::from_u64(1);
+    let __v_57: G = (__v_55 - __v_56);
+    let __v_58: G = (__v_53 * __v_57);
+    let __v_59: G = G::from_u64(0);
+    if (__v_58 != __v_59) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
+    }
+    let __v_60: G = (__v_54 * __v_57);
+    let __v_61: G = G::from_u64(0);
+    if (__v_60 != __v_61) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
+    }
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = (__v_62 - __v_48);
+    let __v_64: G = (__v_16 * __v_54);
+    let __v_65: G = (__v_63 * __v_54);
+    let __v_66: G = (__v_46 * __v_64);
+    let __v_67: G = G::from_u64(7);
+    let __v_68: G = (__v_47 * __v_65);
+    let __v_69: G = (__v_67 * __v_68);
+    let __v_70: G = (__v_46 * __v_65);
+    let __v_71: G = (__v_47 * __v_64);
+    let __v_72: G = (__v_66 + __v_69);
+    let __v_73: G = (__v_70 + __v_71);
+    let __v_74: G = (__v_2 * __v_72);
+    let __v_75: G = G::from_u64(7);
+    let __v_76: G = (__v_3 * __v_73);
+    let __v_77: G = (__v_75 * __v_76);
+    let __v_78: G = (__v_2 * __v_73);
+    let __v_79: G = (__v_3 * __v_72);
+    let __v_80: G = (__v_74 + __v_77);
+    let __v_81: G = (__v_78 + __v_79);
+    let __v_82: G = (__v_44 + __v_80);
+    let __v_83: G = (__v_45 + __v_81);
+    let __ret: [G; OUT_142] = [__v_82, __v_83];
+    if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_143: usize = 2;
+const IN_143: usize = 2;
+const OUT_143: usize = 1;
+fn aiur_fn_143(
+  inp: [G; IN_143],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_143], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(7);
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __v_9: G = (__v_2 * __v_8);
+    let __ret: [G; OUT_143] = [__v_9];
+    if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_144: usize = 8;
+const IN_144: usize = 8;
+const OUT_144: usize = 4;
+fn aiur_fn_144(
+  inp: [G; IN_144],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_144], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_8: G = __loaded[0];
+    let __v_9: G = __loaded[1];
+    let __v_10: G = __loaded[2];
+    let __v_11: G = __loaded[3];
+    let __v_12: G = __loaded[4];
+    let __v_13: G = __loaded[5];
+    let __v_14: G = __loaded[6];
+    let __v_15: G = __loaded[7];
+    let __v_16: G = __loaded[8];
+    let __v_17: G = __loaded[9];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_144] = [__v_4, __v_5, __v_6, __v_7];
+        if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_18: G = __loaded[0];
+        let __v_19: G = __loaded[1];
+        let __v_20: G = __loaded[2];
+        let __v_21: G = __loaded[3];
+        match __v_18.as_canonical_u64() {
+          0u64 => {
+            let __v_22: G = G::from_u64(256);
+            let __v_23: G = (__v_22 * __v_10);
+            let __v_24: G = G::from_u64(65536);
+            let __v_25: G = (__v_24 * __v_11);
+            let __v_26: G = G::from_u64(16777216);
+            let __v_27: G = (__v_26 * __v_12);
+            let __v_28: G = G::from_u64(4294967296);
+            let __v_29: G = (__v_28 * __v_13);
+            let __v_30: G = G::from_u64(1099511627776);
+            let __v_31: G = (__v_30 * __v_14);
+            let __v_32: G = G::from_u64(281474976710656);
+            let __v_33: G = (__v_32 * __v_15);
+            let __v_34: G = G::from_u64(72057594037927936);
+            let __v_35: G = (__v_34 * __v_16);
+            let __v_36: G = (__v_33 + __v_35);
+            let __v_37: G = (__v_31 + __v_36);
+            let __v_38: G = (__v_29 + __v_37);
+            let __v_39: G = (__v_27 + __v_38);
+            let __v_40: G = (__v_25 + __v_39);
+            let __v_41: G = (__v_23 + __v_40);
+            let __v_42: G = (__v_9 + __v_41);
+            let __v_43: G = G::from_u64(0);
+            let __v_44: G = (__v_19 - __v_42);
+            let __v_45: G = (__v_20 - __v_43);
+            let __v_46: G = (__v_6 * __v_44);
+            let __v_47: G = G::from_u64(7);
+            let __v_48: G = (__v_7 * __v_45);
+            let __v_49: G = (__v_47 * __v_48);
+            let __v_50: G = (__v_6 * __v_45);
+            let __v_51: G = (__v_7 * __v_44);
+            let __v_52: G = (__v_46 + __v_49);
+            let __v_53: G = (__v_50 + __v_51);
+            let __v_54: G = (__v_6 * __v_2);
+            let __v_55: G = G::from_u64(7);
+            let __v_56: G = (__v_7 * __v_3);
+            let __v_57: G = (__v_55 * __v_56);
+            let __v_58: G = (__v_6 * __v_3);
+            let __v_59: G = (__v_7 * __v_2);
+            let __v_60: G = (__v_4 + __v_52);
+            let __v_61: G = (__v_5 + __v_53);
+            let __v_62: G = (__v_54 + __v_57);
+            let __v_63: G = (__v_58 + __v_59);
+            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_17, __v_21, __v_2, __v_3, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+            let __v_64: G = __r_arr[0];
+            let __v_65: G = __r_arr[1];
+            let __v_66: G = __r_arr[2];
+            let __v_67: G = __r_arr[3];
+            let __ret: [G; OUT_144] = [__v_64, __v_65, __v_66, __v_67];
+            if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_145: usize = 2;
+const IN_145: usize = 2;
+const OUT_145: usize = 1;
+fn aiur_fn_145(
+  inp: [G; IN_145],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_145], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_145] = [__v_1];
+        if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_145] = [__v_6];
+        if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_146: usize = 2;
+const IN_146: usize = 2;
+const OUT_146: usize = 1;
+fn aiur_fn_146(
+  inp: [G; IN_146],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_146], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_146] = [__v_1];
+        if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_146] = [__v_6];
+        if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_147: usize = 3;
+const IN_147: usize = 3;
+const OUT_147: usize = 1;
+fn aiur_fn_147(
+  inp: [G; IN_147],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_147], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_147] = [__v_2];
+        if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __ret: [G; OUT_147] = [__v_3];
+        if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_148: usize = 2;
+const IN_148: usize = 2;
+const OUT_148: usize = 1;
+fn aiur_fn_148(
+  inp: [G; IN_148],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_148], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_148] = [__v_0];
+        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __ret: [G; OUT_148] = [__v_14];
+        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_149: usize = 10;
+const IN_149: usize = 10;
+const OUT_149: usize = 2;
+fn aiur_fn_149(
+  inp: [G; IN_149],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_149], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    match __v_9.as_canonical_u64() {
+      0u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_149] = [__v_0, __v_12];
+        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        let __v_16: G = __r_arr[2];
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __v_18: G = G::from_u64(0);
+        if (__v_17 != __v_18) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+        }
+        let __ret: [G; OUT_149] = [__v_15, __v_16];
+        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_150: usize = 4;
+const IN_150: usize = 4;
+const OUT_150: usize = 2;
+fn aiur_fn_150(
+  inp: [G; IN_150],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_150], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_150] = [__v_9, __v_0];
+        if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        let __v_13: G = __loaded[6];
+        let __v_14: G = __loaded[7];
+        let __v_15: G = __loaded[8];
+        let __v_16: G = __loaded[9];
+        match __v_7.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __v_22: G = __r_arr[2];
+            let __v_23: G = __r_arr[3];
+            let __v_24: G = __r_arr[4];
+            let __v_25: G = __r_arr[5];
+            let __v_26: G = __r_arr[6];
+            let __v_27: G = __r_arr[7];
+            let __v_28: G = __r_arr[8];
+            let __v_29: G = __r_arr[9];
+            let __v_30: G = __r_arr[10];
+            let __v_31: G = __r_arr[11];
+            let __v_32: G = __r_arr[12];
+            let __v_33: G = __r_arr[13];
+            let __v_34: G = __r_arr[14];
+            let __v_35: G = __r_arr[15];
+            let __v_36: G = __r_arr[16];
+            let __v_37: G = __r_arr[17];
+            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+            let __v_38: G = __r_arr[0];
+            let __v_39: G = __r_arr[1];
+            let __v_40: G = G::from_u64(0);
+            let __v_41: G = G::from_u64(256);
+            let __v_42: G = (__v_41 * __v_21);
+            let __v_43: G = G::from_u64(65536);
+            let __v_44: G = (__v_43 * __v_22);
+            let __v_45: G = G::from_u64(16777216);
+            let __v_46: G = (__v_45 * __v_23);
+            let __v_47: G = G::from_u64(4294967296);
+            let __v_48: G = (__v_47 * __v_24);
+            let __v_49: G = G::from_u64(1099511627776);
+            let __v_50: G = (__v_49 * __v_25);
+            let __v_51: G = G::from_u64(281474976710656);
+            let __v_52: G = (__v_51 * __v_26);
+            let __v_53: G = G::from_u64(72057594037927936);
+            let __v_54: G = (__v_53 * __v_27);
+            let __v_55: G = (__v_52 + __v_54);
+            let __v_56: G = (__v_50 + __v_55);
+            let __v_57: G = (__v_48 + __v_56);
+            let __v_58: G = (__v_46 + __v_57);
+            let __v_59: G = (__v_44 + __v_58);
+            let __v_60: G = (__v_42 + __v_59);
+            let __v_61: G = (__v_20 + __v_60);
+            let __v_62: G = G::from_u64(256);
+            let __v_63: G = (__v_62 * __v_29);
+            let __v_64: G = G::from_u64(65536);
+            let __v_65: G = (__v_64 * __v_30);
+            let __v_66: G = G::from_u64(16777216);
+            let __v_67: G = (__v_66 * __v_31);
+            let __v_68: G = G::from_u64(4294967296);
+            let __v_69: G = (__v_68 * __v_32);
+            let __v_70: G = G::from_u64(1099511627776);
+            let __v_71: G = (__v_70 * __v_33);
+            let __v_72: G = G::from_u64(281474976710656);
+            let __v_73: G = (__v_72 * __v_34);
+            let __v_74: G = G::from_u64(72057594037927936);
+            let __v_75: G = (__v_74 * __v_35);
+            let __v_76: G = (__v_73 + __v_75);
+            let __v_77: G = (__v_71 + __v_76);
+            let __v_78: G = (__v_69 + __v_77);
+            let __v_79: G = (__v_67 + __v_78);
+            let __v_80: G = (__v_65 + __v_79);
+            let __v_81: G = (__v_63 + __v_80);
+            let __v_82: G = (__v_28 + __v_81);
+            let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_150] = [__v_83, __v_39];
+            if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_151: usize = 5;
+const IN_151: usize = 5;
+const OUT_151: usize = 1;
+fn aiur_fn_151(
+  inp: [G; IN_151],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_151], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_151] = [__v_5];
+        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = (__v_1 - __v_4);
+        let __v_7: G = (__v_5 + __v_6);
+        let __v_8: G = G::from_bool((__v_7 == G::ZERO));
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __v_9: G = G::from_u64(1);
+            let __ret: [G; OUT_151] = [__v_9];
+            if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_2 - __v_9);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_3 + __v_11);
+            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __ret: [G; OUT_151] = [__v_13];
+            if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_152: usize = 4;
+const IN_152: usize = 4;
+const OUT_152: usize = 1;
+fn aiur_fn_152(
+  inp: [G; IN_152],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_152], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_152] = [__v_6];
+        if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_3 - __v_6);
+            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_152] = [__v_8];
+            if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_3 - __v_11);
+            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_152] = [__v_14];
+            if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_153: usize = 8;
+const IN_153: usize = 8;
+const OUT_153: usize = 1;
+fn aiur_fn_153(
+  inp: [G; IN_153],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_153], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_8: G = __loaded[0];
+    let __v_9: G = __loaded[1];
+    let __v_10: G = __loaded[2];
+    let __v_11: G = __loaded[3];
+    let __v_12: G = __loaded[4];
+    let __v_13: G = __loaded[5];
+    let __v_14: G = __loaded[6];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        let __v_15: G = G::from_u64(1);
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_153] = [__v_17];
+        if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_9.as_canonical_u64() {
+          _ => {
+            let __v_15: G = (__v_9 - __v_1);
+            let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+            match __v_16.as_canonical_u64() {
+              1u64 => {
+                let __v_17: G = G::from_u64(0);
+                let __v_18: G = G::from_u64(0);
+                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+                let __v_19: G = __r_arr[0];
+                let __v_20: G = __r_arr[1];
+                let __v_21: G = __r_arr[2];
+                let __v_22: G = __r_arr[3];
+                let __v_23: G = (__v_4 * __v_19);
+                let __v_24: G = G::from_u64(7);
+                let __v_25: G = (__v_5 * __v_20);
+                let __v_26: G = (__v_24 * __v_25);
+                let __v_27: G = (__v_4 * __v_20);
+                let __v_28: G = (__v_5 * __v_19);
+                let __v_29: G = (__v_23 + __v_26);
+                let __v_30: G = (__v_27 + __v_28);
+                let __v_31: G = (__v_12 + __v_29);
+                let __v_32: G = (__v_13 + __v_30);
+                let __v_33: G = G::from_u64(0);
+                let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_153] = [__v_34];
+                if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_17: G = G::from_u64(0);
+                let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+                let __v_18: G = __r_arr[0];
+                let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_153] = [__v_19];
+                if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_154: usize = 2;
+const IN_154: usize = 2;
+const OUT_154: usize = 1;
+fn aiur_fn_154(
+  inp: [G; IN_154],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_154], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(1);
+        let __ret: [G; OUT_154] = [__v_9];
+        if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_9: G = (__v_3 - __v_1);
+            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
+            match __v_10.as_canonical_u64() {
+              1u64 => {
+                let __v_11: G = G::from_u64(0);
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = (__v_6 - __v_11);
+                let __v_14: G = (__v_7 - __v_12);
+                let __v_15: G = G::from_bool((__v_13 == G::ZERO));
+                let __v_16: G = G::from_bool((__v_14 == G::ZERO));
+                let __v_17: G = (__v_15 * __v_16);
+                let __v_18: G = G::from_u64(1);
+                if (__v_17 != __v_18) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+                }
+                let __v_19: G = G::from_u64(1);
+                let __ret: [G; OUT_154] = [__v_19];
+                if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_154] = [__v_11];
+                if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_155: usize = 2;
+const IN_155: usize = 2;
+const OUT_155: usize = 1;
+fn aiur_fn_155(
+  inp: [G; IN_155],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_155], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_155] = [__v_2];
+        if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_155] = [__v_2];
+        if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_156: usize = 10;
+const IN_156: usize = 10;
+const OUT_156: usize = 1;
+fn aiur_fn_156(
+  inp: [G; IN_156],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_156], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = (__v_3 - __v_1);
+    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(7);
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(1);
+    let __v_15: G = G::from_u64(1);
+    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    let __v_19: G = (__v_12 * __v_18);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = (__v_4 - __v_19);
+    let __v_22: G = (__v_5 - __v_20);
+    let __v_23: G = (__v_21 * __v_21);
+    let __v_24: G = G::from_u64(7);
+    let __v_25: G = (__v_22 * __v_22);
+    let __v_26: G = (__v_24 * __v_25);
+    let __v_27: G = (__v_23 - __v_26);
+    let __v_28: G = g_inverse_value(__v_27);
+    let __v_29: G = (__v_27 * __v_28);
+    let __v_30: G = G::from_u64(1);
+    let __v_31: G = (__v_29 - __v_30);
+    let __v_32: G = (__v_27 * __v_31);
+    let __v_33: G = G::from_u64(0);
+    if (__v_32 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
+    }
+    let __v_34: G = (__v_28 * __v_31);
+    let __v_35: G = G::from_u64(0);
+    if (__v_34 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: None });
+    }
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = (__v_36 - __v_22);
+    let __v_38: G = (__v_21 * __v_28);
+    let __v_39: G = (__v_37 * __v_28);
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+    let __v_40: G = __r_arr[0];
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+    let __v_41: G = __r_arr[0];
+    let __v_42: G = (__v_40 - __v_41);
+    let __v_43: G = G::from_bool((__v_42 == G::ZERO));
+    let __v_44: G = G::from_u64(1);
+    if (__v_43 != __v_44) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1, __v_6, __v_7, __v_38, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+    let __v_45: G = __r_arr[0];
+    let __ret: [G; OUT_156] = [__v_45];
+    if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_157: usize = 11;
+const IN_157: usize = 11;
+const OUT_157: usize = 1;
+fn aiur_fn_157(
+  inp: [G; IN_157],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_157], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = G::from_u64(0);
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __v_13: G = G::from_u64(1);
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = (__v_5 * __v_15);
+    let __v_18: G = G::from_u64(7);
+    let __v_19: G = (__v_6 * __v_16);
+    let __v_20: G = (__v_18 * __v_19);
+    let __v_21: G = (__v_5 * __v_16);
+    let __v_22: G = (__v_6 * __v_15);
+    let __v_23: G = (__v_17 + __v_20);
+    let __v_24: G = (__v_21 + __v_22);
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __v_25: G = __r_arr[0];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_25, __v_3, __v_1, __v_2, __v_23, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __v_26: G = __r_arr[0];
+    let __ret: [G; OUT_157] = [__v_26];
+    if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_158: usize = 13;
+const IN_158: usize = 13;
+const OUT_158: usize = 1;
+fn aiur_fn_158(
+  inp: [G; IN_158],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_158], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_158] = [__v_0];
+        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __v_18: G = G::from_u64(1);
+        let __v_19: G = (__v_4 + __v_18);
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_5 - __v_20);
+        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __v_22: G = __r_arr[0];
+        let __ret: [G; OUT_158] = [__v_22];
+        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_159: usize = 13;
+const IN_159: usize = 13;
+const OUT_159: usize = 1;
+fn aiur_fn_159(
+  inp: [G; IN_159],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_159], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_159] = [__v_0];
+        if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_18: G = __r_arr[0];
+        let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_4 + __v_20);
+        let __v_22: G = G::from_u64(1);
+        let __v_23: G = (__v_5 - __v_22);
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __ret: [G; OUT_159] = [__v_24];
+        if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_160: usize = 15;
+const IN_160: usize = 15;
+const OUT_160: usize = 1;
+fn aiur_fn_160(
+  inp: [G; IN_160],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_160], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_160] = [__v_0];
+        if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        match __v_15.as_canonical_u64() {
+          0u64 => {
+            let __v_17: G = G::from_u64(1);
+            let __v_18: G = (__v_4 + __v_17);
+            let __v_19: G = G::from_u64(1);
+            let __v_20: G = (__v_5 - __v_19);
+            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __ret: [G; OUT_160] = [__v_21];
+            if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __v_18: G = (__v_17 + __v_3);
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __v_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __v_22: G = G::from_u64(1);
+            let __v_23: G = (__v_4 + __v_22);
+            let __v_24: G = G::from_u64(1);
+            let __v_25: G = (__v_5 - __v_24);
+            let __v_26: G = G::from_u64(1);
+            let __v_27: G = (__v_6 + __v_26);
+            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __ret: [G; OUT_160] = [__v_28];
+            if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_161: usize = 15;
+const IN_161: usize = 15;
+const OUT_161: usize = 1;
+fn aiur_fn_161(
+  inp: [G; IN_161],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_161], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_161] = [__v_0];
+        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_15: G = G::from_u64(3);
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        match __v_16.as_canonical_u64() {
+          _ => {
+            let __v_18: G = G::from_u64(0);
+            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_6, __v_10, __v_5, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+            let __v_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            let __v_23: G = (__v_21 - __v_22);
+            let __v_24: G = G::from_bool((__v_23 == G::ZERO));
+            let __v_25: G = G::from_u64(1);
+            if (__v_24 != __v_25) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
+            }
+            let __v_26: G = (__v_9 - __v_20);
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+            let __v_27: G = __r_arr[0];
+            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __v_29: G = G::from_u64(1);
+            if (__v_28 != __v_29) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+            }
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
+            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_0, __v_8, __v_9, __v_10, __v_30, __v_7, __v_31, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+            let __v_32: G = __r_arr[0];
+            let __ret: [G; OUT_161] = [__v_32];
+            if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_162: usize = 4;
+const IN_162: usize = 4;
+const OUT_162: usize = 1;
+fn aiur_fn_162(
+  inp: [G; IN_162],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_162], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_162] = [__v_6];
+        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = (__v_5 + __v_1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 - __v_7);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_3 + __v_9);
+        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_162] = [__v_12];
+        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_163: usize = 1;
+const IN_163: usize = 1;
+const OUT_163: usize = 1;
+fn aiur_fn_163(
+  inp: [G; IN_163],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_163], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_163] = [__v_4];
+        if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_163] = [__v_4];
+            if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __ret: [G; OUT_163] = [__v_2];
+            if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_164: usize = 5;
+const IN_164: usize = 5;
+const OUT_164: usize = 1;
+fn aiur_fn_164(
+  inp: [G; IN_164],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_164], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_164] = [__v_7];
+        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_3 - __v_7);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_4 + __v_9);
+            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_164] = [__v_11];
+            if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = (__v_8 + __v_1);
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_3 - __v_10);
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = (__v_4 + __v_12);
+            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_164] = [__v_15];
+            if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_165: usize = 5;
+const IN_165: usize = 5;
+const OUT_165: usize = 4;
+fn aiur_fn_165(
+  inp: [G; IN_165],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_165], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_165] = [__v_1, __v_2, __v_3, __v_4];
+        if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __ret: [G; OUT_165] = [__v_3, __v_4, __v_1, __v_2];
+        if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_166: usize = 4;
+const IN_166: usize = 4;
+const OUT_166: usize = 1;
+fn aiur_fn_166(
+  inp: [G; IN_166],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_166], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
+    let __v_4: G = G::from_u8(__gb[0]);
+    let __v_5: G = G::from_u8(__gb[1]);
+    let __v_6: G = G::from_u8(__gb[2]);
+    let __v_7: G = G::from_u8(__gb[3]);
+    let __v_8: G = G::from_u8(__gb[4]);
+    let __v_9: G = G::from_u8(__gb[5]);
+    let __v_10: G = G::from_u8(__gb[6]);
+    let __v_11: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_12: G = G::from_u64(1020);
+    let __v_13: G = (__v_11 - __v_12);
+    let __v_14: G = (__v_10 + __v_13);
+    let __v_15: G = (__v_9 + __v_14);
+    let __v_16: G = (__v_8 + __v_15);
+    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
+    let __v_18: G = (__v_6 + __v_7);
+    let __v_19: G = (__v_5 + __v_18);
+    let __v_20: G = (__v_4 + __v_19);
+    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
+    let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes();
+    let __v_22: G = G::from_u8(__gb[0]);
+    let __v_23: G = G::from_u8(__gb[1]);
+    let __v_24: G = G::from_u8(__gb[2]);
+    let __v_25: G = G::from_u8(__gb[3]);
+    let __v_26: G = G::from_u8(__gb[4]);
+    let __v_27: G = G::from_u8(__gb[5]);
+    let __v_28: G = G::from_u8(__gb[6]);
+    let __v_29: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_22; let __vj = __v_23; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_30: G = G::from_u64(1020);
+    let __v_31: G = (__v_29 - __v_30);
+    let __v_32: G = (__v_28 + __v_31);
+    let __v_33: G = (__v_27 + __v_32);
+    let __v_34: G = (__v_26 + __v_33);
+    let __v_35: G = G::from_bool((__v_34 == G::ZERO));
+    let __v_36: G = (__v_24 + __v_25);
+    let __v_37: G = (__v_23 + __v_36);
+    let __v_38: G = (__v_22 + __v_37);
+    let __v_39: G = G::from_bool((__v_38 == G::ZERO));
+    let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes();
+    let __v_40: G = G::from_u8(__gb[0]);
+    let __v_41: G = G::from_u8(__gb[1]);
+    let __v_42: G = G::from_u8(__gb[2]);
+    let __v_43: G = G::from_u8(__gb[3]);
+    let __v_44: G = G::from_u8(__gb[4]);
+    let __v_45: G = G::from_u8(__gb[5]);
+    let __v_46: G = G::from_u8(__gb[6]);
+    let __v_47: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_48: G = G::from_u64(1020);
+    let __v_49: G = (__v_47 - __v_48);
+    let __v_50: G = (__v_46 + __v_49);
+    let __v_51: G = (__v_45 + __v_50);
+    let __v_52: G = (__v_44 + __v_51);
+    let __v_53: G = G::from_bool((__v_52 == G::ZERO));
+    let __v_54: G = (__v_42 + __v_43);
+    let __v_55: G = (__v_41 + __v_54);
+    let __v_56: G = (__v_40 + __v_55);
+    let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+    let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
+    let __v_58: G = G::from_u8(__gb[0]);
+    let __v_59: G = G::from_u8(__gb[1]);
+    let __v_60: G = G::from_u8(__gb[2]);
+    let __v_61: G = G::from_u8(__gb[3]);
+    let __v_62: G = G::from_u8(__gb[4]);
+    let __v_63: G = G::from_u8(__gb[5]);
+    let __v_64: G = G::from_u8(__gb[6]);
+    let __v_65: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_66: G = G::from_u64(1020);
+    let __v_67: G = (__v_65 - __v_66);
+    let __v_68: G = (__v_64 + __v_67);
+    let __v_69: G = (__v_63 + __v_68);
+    let __v_70: G = (__v_62 + __v_69);
+    let __v_71: G = G::from_bool((__v_70 == G::ZERO));
+    let __v_72: G = (__v_60 + __v_61);
+    let __v_73: G = (__v_59 + __v_72);
+    let __v_74: G = (__v_58 + __v_73);
+    let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = G::from_u64(256);
+    let __v_78: G = (__v_77 * __v_5);
+    let __v_79: G = G::from_u64(65536);
+    let __v_80: G = (__v_79 * __v_6);
+    let __v_81: G = G::from_u64(16777216);
+    let __v_82: G = (__v_81 * __v_7);
+    let __v_83: G = G::from_u64(4294967296);
+    let __v_84: G = (__v_83 * __v_8);
+    let __v_85: G = G::from_u64(1099511627776);
+    let __v_86: G = (__v_85 * __v_9);
+    let __v_87: G = G::from_u64(281474976710656);
+    let __v_88: G = (__v_87 * __v_10);
+    let __v_89: G = G::from_u64(72057594037927936);
+    let __v_90: G = (__v_89 * __v_11);
+    let __v_91: G = (__v_88 + __v_90);
+    let __v_92: G = (__v_86 + __v_91);
+    let __v_93: G = (__v_84 + __v_92);
+    let __v_94: G = (__v_82 + __v_93);
+    let __v_95: G = (__v_80 + __v_94);
+    let __v_96: G = (__v_78 + __v_95);
+    let __v_97: G = (__v_4 + __v_96);
+    if (__v_97 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
+    }
+    let __v_98: G = G::from_u64(1);
+    let __v_99: G = G::from_u64(1);
+    let __v_100: G = (__v_99 - __v_21);
+    let __v_101: G = (__v_17 * __v_100);
+    let __v_102: G = (__v_98 - __v_101);
+    let __v_103: G = G::from_u64(1);
+    if (__v_102 != __v_103) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None });
+    }
+    let __v_104: G = G::from_u64(0);
+    let __v_105: G = G::from_u64(256);
+    let __v_106: G = (__v_105 * __v_23);
+    let __v_107: G = G::from_u64(65536);
+    let __v_108: G = (__v_107 * __v_24);
+    let __v_109: G = G::from_u64(16777216);
+    let __v_110: G = (__v_109 * __v_25);
+    let __v_111: G = G::from_u64(4294967296);
+    let __v_112: G = (__v_111 * __v_26);
+    let __v_113: G = G::from_u64(1099511627776);
+    let __v_114: G = (__v_113 * __v_27);
+    let __v_115: G = G::from_u64(281474976710656);
+    let __v_116: G = (__v_115 * __v_28);
+    let __v_117: G = G::from_u64(72057594037927936);
+    let __v_118: G = (__v_117 * __v_29);
+    let __v_119: G = (__v_116 + __v_118);
+    let __v_120: G = (__v_114 + __v_119);
+    let __v_121: G = (__v_112 + __v_120);
+    let __v_122: G = (__v_110 + __v_121);
+    let __v_123: G = (__v_108 + __v_122);
+    let __v_124: G = (__v_106 + __v_123);
+    let __v_125: G = (__v_22 + __v_124);
+    if (__v_125 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
+    }
+    let __v_126: G = G::from_u64(1);
+    let __v_127: G = G::from_u64(1);
+    let __v_128: G = (__v_127 - __v_39);
+    let __v_129: G = (__v_35 * __v_128);
+    let __v_130: G = (__v_126 - __v_129);
+    let __v_131: G = G::from_u64(1);
+    if (__v_130 != __v_131) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
+    }
+    let __v_132: G = G::from_u64(0);
+    let __v_133: G = G::from_u64(256);
+    let __v_134: G = (__v_133 * __v_41);
+    let __v_135: G = G::from_u64(65536);
+    let __v_136: G = (__v_135 * __v_42);
+    let __v_137: G = G::from_u64(16777216);
+    let __v_138: G = (__v_137 * __v_43);
+    let __v_139: G = G::from_u64(4294967296);
+    let __v_140: G = (__v_139 * __v_44);
+    let __v_141: G = G::from_u64(1099511627776);
+    let __v_142: G = (__v_141 * __v_45);
+    let __v_143: G = G::from_u64(281474976710656);
+    let __v_144: G = (__v_143 * __v_46);
+    let __v_145: G = G::from_u64(72057594037927936);
+    let __v_146: G = (__v_145 * __v_47);
+    let __v_147: G = (__v_144 + __v_146);
+    let __v_148: G = (__v_142 + __v_147);
+    let __v_149: G = (__v_140 + __v_148);
+    let __v_150: G = (__v_138 + __v_149);
+    let __v_151: G = (__v_136 + __v_150);
+    let __v_152: G = (__v_134 + __v_151);
+    let __v_153: G = (__v_40 + __v_152);
+    if (__v_153 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
+    }
+    let __v_154: G = G::from_u64(1);
+    let __v_155: G = G::from_u64(1);
+    let __v_156: G = (__v_155 - __v_57);
+    let __v_157: G = (__v_53 * __v_156);
+    let __v_158: G = (__v_154 - __v_157);
+    let __v_159: G = G::from_u64(1);
+    if (__v_158 != __v_159) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_159.as_canonical_u64(), msg: None });
+    }
+    let __v_160: G = G::from_u64(0);
+    let __v_161: G = G::from_u64(256);
+    let __v_162: G = (__v_161 * __v_59);
+    let __v_163: G = G::from_u64(65536);
+    let __v_164: G = (__v_163 * __v_60);
+    let __v_165: G = G::from_u64(16777216);
+    let __v_166: G = (__v_165 * __v_61);
+    let __v_167: G = G::from_u64(4294967296);
+    let __v_168: G = (__v_167 * __v_62);
+    let __v_169: G = G::from_u64(1099511627776);
+    let __v_170: G = (__v_169 * __v_63);
+    let __v_171: G = G::from_u64(281474976710656);
+    let __v_172: G = (__v_171 * __v_64);
+    let __v_173: G = G::from_u64(72057594037927936);
+    let __v_174: G = (__v_173 * __v_65);
+    let __v_175: G = (__v_172 + __v_174);
+    let __v_176: G = (__v_170 + __v_175);
+    let __v_177: G = (__v_168 + __v_176);
+    let __v_178: G = (__v_166 + __v_177);
+    let __v_179: G = (__v_164 + __v_178);
+    let __v_180: G = (__v_162 + __v_179);
+    let __v_181: G = (__v_58 + __v_180);
+    if (__v_181 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+    }
+    let __v_182: G = G::from_u64(1);
+    let __v_183: G = G::from_u64(1);
+    let __v_184: G = (__v_183 - __v_75);
+    let __v_185: G = (__v_71 * __v_184);
+    let __v_186: G = (__v_182 - __v_185);
+    let __v_187: G = G::from_u64(1);
+    if (__v_186 != __v_187) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: None });
+    }
+    let __v_188: G = G::from_u64(1);
+    let __v_189: G = G::from_u64(1);
+    let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_166] = [__v_194];
+    if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_167: usize = 6;
+const IN_167: usize = 6;
+const OUT_167: usize = 3;
+fn aiur_fn_167(
+  inp: [G; IN_167],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_167], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    let __v_9: G = __loaded[3];
+    let __v_10: G = __loaded[4];
+    let __v_11: G = __loaded[5];
+    let __v_12: G = __loaded[6];
+    match __v_6.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_167] = [__v_0, __v_1, __v_5];
+        if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_7.as_canonical_u64() {
+          _ => {
+            let __v_13: G = (__v_7 - __v_2);
+            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+            match __v_14.as_canonical_u64() {
+              1u64 => {
+                let __v_15: G = G::from_u64(1);
+                let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+                let __v_16: G = __r_arr[0];
+                let __v_17: G = __r_arr[1];
+                let __v_18: G = (__v_16 * __v_10);
+                let __v_19: G = G::from_u64(7);
+                let __v_20: G = (__v_17 * __v_11);
+                let __v_21: G = (__v_19 * __v_20);
+                let __v_22: G = (__v_16 * __v_11);
+                let __v_23: G = (__v_17 * __v_10);
+                let __v_24: G = (__v_18 + __v_21);
+                let __v_25: G = (__v_22 + __v_23);
+                let __v_26: G = (__v_0 + __v_24);
+                let __v_27: G = (__v_1 + __v_25);
+                let __ret: [G; OUT_167] = [__v_26, __v_27, __v_12];
+                if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __ret: [G; OUT_167] = [__v_0, __v_1, __v_5];
+                if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_168: usize = 9;
+const IN_168: usize = 9;
+const OUT_168: usize = 2;
+fn aiur_fn_168(
+  inp: [G; IN_168],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_168], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_9: G = __loaded[0];
+    let __v_10: G = __loaded[1];
+    let __v_11: G = __loaded[2];
+    let __v_12: G = __loaded[3];
+    let __v_13: G = __loaded[4];
+    match __v_9.as_canonical_u64() {
+      1u64 => {
+        let __v_14: G = (__v_6 - __v_8);
+        let __v_15: G = G::from_bool((__v_14 == G::ZERO));
+        let __v_16: G = G::from_u64(1);
+        if (__v_15 != __v_16) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __v_18: G = G::from_u64(0);
+        if (__v_17 != __v_18) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+        }
+        let __ret: [G; OUT_168] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_14: G = __loaded[0];
+        let __v_15: G = __loaded[1];
+        let __v_16: G = __loaded[2];
+        let __v_17: G = __loaded[3];
+        match __v_14.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_18: G = __loaded[0];
+            let __v_19: G = __loaded[1];
+            let __v_20: G = __loaded[2];
+            match __v_18.as_canonical_u64() {
+              0u64 => {
+                match __v_10.as_canonical_u64() {
+                  _ => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_21: G = __loaded[0];
+                    let __v_22: G = __loaded[1];
+                    let __v_23: G = __loaded[2];
+                    match __v_21.as_canonical_u64() {
+                      0u64 => {
+                        let __v_24: G = G::from_u64(1);
+                        let __v_25: G = (__v_6 - __v_24);
+                        let __v_26: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                        let __v_27: G = __r_arr[0];
+                        let __v_28: G = __r_arr[1];
+                        let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_22.as_canonical_u64() {
+  0u64 => {
+    break '__mc_0 [__v_0, __v_1, __v_27, __v_28];
+  },
+  _ => {
+    break '__mc_0 [__v_27, __v_28, __v_0, __v_1];
+  },
+}
+ };
+                        let __v_29: G = __mc_out___mc_0[0];
+                        let __v_30: G = __mc_out___mc_0[1];
+                        let __v_31: G = __mc_out___mc_0[2];
+                        let __v_32: G = __mc_out___mc_0[3];
+                        let __gb: [u8; 8] = __v_29.as_canonical_u64().to_le_bytes();
+                        let __v_33: G = G::from_u8(__gb[0]);
+                        let __v_34: G = G::from_u8(__gb[1]);
+                        let __v_35: G = G::from_u8(__gb[2]);
+                        let __v_36: G = G::from_u8(__gb[3]);
+                        let __v_37: G = G::from_u8(__gb[4]);
+                        let __v_38: G = G::from_u8(__gb[5]);
+                        let __v_39: G = G::from_u8(__gb[6]);
+                        let __v_40: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        let __v_41: G = G::from_u64(1020);
+                        let __v_42: G = (__v_40 - __v_41);
+                        let __v_43: G = (__v_39 + __v_42);
+                        let __v_44: G = (__v_38 + __v_43);
+                        let __v_45: G = (__v_37 + __v_44);
+                        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
+                        let __v_47: G = (__v_35 + __v_36);
+                        let __v_48: G = (__v_34 + __v_47);
+                        let __v_49: G = (__v_33 + __v_48);
+                        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
+                        let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes();
+                        let __v_51: G = G::from_u8(__gb[0]);
+                        let __v_52: G = G::from_u8(__gb[1]);
+                        let __v_53: G = G::from_u8(__gb[2]);
+                        let __v_54: G = G::from_u8(__gb[3]);
+                        let __v_55: G = G::from_u8(__gb[4]);
+                        let __v_56: G = G::from_u8(__gb[5]);
+                        let __v_57: G = G::from_u8(__gb[6]);
+                        let __v_58: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_55; let __vj = __v_56; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_57; let __vj = __v_58; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        let __v_59: G = G::from_u64(1020);
+                        let __v_60: G = (__v_58 - __v_59);
+                        let __v_61: G = (__v_57 + __v_60);
+                        let __v_62: G = (__v_56 + __v_61);
+                        let __v_63: G = (__v_55 + __v_62);
+                        let __v_64: G = G::from_bool((__v_63 == G::ZERO));
+                        let __v_65: G = (__v_53 + __v_54);
+                        let __v_66: G = (__v_52 + __v_65);
+                        let __v_67: G = (__v_51 + __v_66);
+                        let __v_68: G = G::from_bool((__v_67 == G::ZERO));
+                        let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes();
+                        let __v_69: G = G::from_u8(__gb[0]);
+                        let __v_70: G = G::from_u8(__gb[1]);
+                        let __v_71: G = G::from_u8(__gb[2]);
+                        let __v_72: G = G::from_u8(__gb[3]);
+                        let __v_73: G = G::from_u8(__gb[4]);
+                        let __v_74: G = G::from_u8(__gb[5]);
+                        let __v_75: G = G::from_u8(__gb[6]);
+                        let __v_76: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_69; let __vj = __v_70; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_75; let __vj = __v_76; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        let __v_77: G = G::from_u64(1020);
+                        let __v_78: G = (__v_76 - __v_77);
+                        let __v_79: G = (__v_75 + __v_78);
+                        let __v_80: G = (__v_74 + __v_79);
+                        let __v_81: G = (__v_73 + __v_80);
+                        let __v_82: G = G::from_bool((__v_81 == G::ZERO));
+                        let __v_83: G = (__v_71 + __v_72);
+                        let __v_84: G = (__v_70 + __v_83);
+                        let __v_85: G = (__v_69 + __v_84);
+                        let __v_86: G = G::from_bool((__v_85 == G::ZERO));
+                        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
+                        let __v_87: G = G::from_u8(__gb[0]);
+                        let __v_88: G = G::from_u8(__gb[1]);
+                        let __v_89: G = G::from_u8(__gb[2]);
+                        let __v_90: G = G::from_u8(__gb[3]);
+                        let __v_91: G = G::from_u8(__gb[4]);
+                        let __v_92: G = G::from_u8(__gb[5]);
+                        let __v_93: G = G::from_u8(__gb[6]);
+                        let __v_94: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_93; let __vj = __v_94; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        let __v_95: G = G::from_u64(1020);
+                        let __v_96: G = (__v_94 - __v_95);
+                        let __v_97: G = (__v_93 + __v_96);
+                        let __v_98: G = (__v_92 + __v_97);
+                        let __v_99: G = (__v_91 + __v_98);
+                        let __v_100: G = G::from_bool((__v_99 == G::ZERO));
+                        let __v_101: G = (__v_89 + __v_90);
+                        let __v_102: G = (__v_88 + __v_101);
+                        let __v_103: G = (__v_87 + __v_102);
+                        let __v_104: G = G::from_bool((__v_103 == G::ZERO));
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
+                        let __v_105: G = __r_arr[0];
+                        let __v_106: G = __r_arr[1];
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                        let __v_107: G = __r_arr[0];
+                        let __v_108: G = __r_arr[1];
+                        let __v_109: G = __r_arr[2];
+                        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+                        let __v_110: G = __r_arr[0];
+                        let __v_111: G = G::from_u64(1);
+                        if (__v_110 != __v_111) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_110.as_canonical_u64(), rhs: __v_111.as_canonical_u64(), msg: None });
+                        }
+                        let __v_112: G = G::from_u64(0);
+                        let __v_113: G = G::from_u64(0);
+                        let __v_114: G = G::from_u64(256);
+                        let __v_115: G = (__v_114 * __v_34);
+                        let __v_116: G = G::from_u64(65536);
+                        let __v_117: G = (__v_116 * __v_35);
+                        let __v_118: G = G::from_u64(16777216);
+                        let __v_119: G = (__v_118 * __v_36);
+                        let __v_120: G = G::from_u64(4294967296);
+                        let __v_121: G = (__v_120 * __v_37);
+                        let __v_122: G = G::from_u64(1099511627776);
+                        let __v_123: G = (__v_122 * __v_38);
+                        let __v_124: G = G::from_u64(281474976710656);
+                        let __v_125: G = (__v_124 * __v_39);
+                        let __v_126: G = G::from_u64(72057594037927936);
+                        let __v_127: G = (__v_126 * __v_40);
+                        let __v_128: G = (__v_125 + __v_127);
+                        let __v_129: G = (__v_123 + __v_128);
+                        let __v_130: G = (__v_121 + __v_129);
+                        let __v_131: G = (__v_119 + __v_130);
+                        let __v_132: G = (__v_117 + __v_131);
+                        let __v_133: G = (__v_115 + __v_132);
+                        let __v_134: G = (__v_33 + __v_133);
+                        if (__v_134 != __v_29) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+                        }
+                        let __v_135: G = G::from_u64(1);
+                        let __v_136: G = G::from_u64(1);
+                        let __v_137: G = (__v_136 - __v_50);
+                        let __v_138: G = (__v_46 * __v_137);
+                        let __v_139: G = (__v_135 - __v_138);
+                        let __v_140: G = G::from_u64(1);
+                        if (__v_139 != __v_140) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: None });
+                        }
+                        let __v_141: G = G::from_u64(0);
+                        let __v_142: G = G::from_u64(256);
+                        let __v_143: G = (__v_142 * __v_52);
+                        let __v_144: G = G::from_u64(65536);
+                        let __v_145: G = (__v_144 * __v_53);
+                        let __v_146: G = G::from_u64(16777216);
+                        let __v_147: G = (__v_146 * __v_54);
+                        let __v_148: G = G::from_u64(4294967296);
+                        let __v_149: G = (__v_148 * __v_55);
+                        let __v_150: G = G::from_u64(1099511627776);
+                        let __v_151: G = (__v_150 * __v_56);
+                        let __v_152: G = G::from_u64(281474976710656);
+                        let __v_153: G = (__v_152 * __v_57);
+                        let __v_154: G = G::from_u64(72057594037927936);
+                        let __v_155: G = (__v_154 * __v_58);
+                        let __v_156: G = (__v_153 + __v_155);
+                        let __v_157: G = (__v_151 + __v_156);
+                        let __v_158: G = (__v_149 + __v_157);
+                        let __v_159: G = (__v_147 + __v_158);
+                        let __v_160: G = (__v_145 + __v_159);
+                        let __v_161: G = (__v_143 + __v_160);
+                        let __v_162: G = (__v_51 + __v_161);
+                        if (__v_162 != __v_30) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
+                        }
+                        let __v_163: G = G::from_u64(1);
+                        let __v_164: G = G::from_u64(1);
+                        let __v_165: G = (__v_164 - __v_68);
+                        let __v_166: G = (__v_64 * __v_165);
+                        let __v_167: G = (__v_163 - __v_166);
+                        let __v_168: G = G::from_u64(1);
+                        if (__v_167 != __v_168) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_168.as_canonical_u64(), msg: None });
+                        }
+                        let __v_169: G = G::from_u64(0);
+                        let __v_170: G = G::from_u64(256);
+                        let __v_171: G = (__v_170 * __v_70);
+                        let __v_172: G = G::from_u64(65536);
+                        let __v_173: G = (__v_172 * __v_71);
+                        let __v_174: G = G::from_u64(16777216);
+                        let __v_175: G = (__v_174 * __v_72);
+                        let __v_176: G = G::from_u64(4294967296);
+                        let __v_177: G = (__v_176 * __v_73);
+                        let __v_178: G = G::from_u64(1099511627776);
+                        let __v_179: G = (__v_178 * __v_74);
+                        let __v_180: G = G::from_u64(281474976710656);
+                        let __v_181: G = (__v_180 * __v_75);
+                        let __v_182: G = G::from_u64(72057594037927936);
+                        let __v_183: G = (__v_182 * __v_76);
+                        let __v_184: G = (__v_181 + __v_183);
+                        let __v_185: G = (__v_179 + __v_184);
+                        let __v_186: G = (__v_177 + __v_185);
+                        let __v_187: G = (__v_175 + __v_186);
+                        let __v_188: G = (__v_173 + __v_187);
+                        let __v_189: G = (__v_171 + __v_188);
+                        let __v_190: G = (__v_69 + __v_189);
+                        if (__v_190 != __v_31) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+                        }
+                        let __v_191: G = G::from_u64(1);
+                        let __v_192: G = G::from_u64(1);
+                        let __v_193: G = (__v_192 - __v_86);
+                        let __v_194: G = (__v_82 * __v_193);
+                        let __v_195: G = (__v_191 - __v_194);
+                        let __v_196: G = G::from_u64(1);
+                        if (__v_195 != __v_196) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None });
+                        }
+                        let __v_197: G = G::from_u64(0);
+                        let __v_198: G = G::from_u64(256);
+                        let __v_199: G = (__v_198 * __v_88);
+                        let __v_200: G = G::from_u64(65536);
+                        let __v_201: G = (__v_200 * __v_89);
+                        let __v_202: G = G::from_u64(16777216);
+                        let __v_203: G = (__v_202 * __v_90);
+                        let __v_204: G = G::from_u64(4294967296);
+                        let __v_205: G = (__v_204 * __v_91);
+                        let __v_206: G = G::from_u64(1099511627776);
+                        let __v_207: G = (__v_206 * __v_92);
+                        let __v_208: G = G::from_u64(281474976710656);
+                        let __v_209: G = (__v_208 * __v_93);
+                        let __v_210: G = G::from_u64(72057594037927936);
+                        let __v_211: G = (__v_210 * __v_94);
+                        let __v_212: G = (__v_209 + __v_211);
+                        let __v_213: G = (__v_207 + __v_212);
+                        let __v_214: G = (__v_205 + __v_213);
+                        let __v_215: G = (__v_203 + __v_214);
+                        let __v_216: G = (__v_201 + __v_215);
+                        let __v_217: G = (__v_199 + __v_216);
+                        let __v_218: G = (__v_87 + __v_217);
+                        if (__v_218 != __v_32) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+                        }
+                        let __v_219: G = G::from_u64(1);
+                        let __v_220: G = G::from_u64(1);
+                        let __v_221: G = (__v_220 - __v_104);
+                        let __v_222: G = (__v_100 * __v_221);
+                        let __v_223: G = (__v_219 - __v_222);
+                        let __v_224: G = G::from_u64(1);
+                        if (__v_223 != __v_224) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_224.as_canonical_u64(), msg: None });
+                        }
+                        let __v_225: G = G::from_u64(1);
+                        let __v_226: G = G::from_u64(1);
+                        let __v_227: G = { let __values: [G; 10] = [__v_225, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_228: G = { let __values: [G; 10] = [__v_197, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_227]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_229: G = { let __values: [G; 10] = [__v_169, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_230: G = { let __values: [G; 10] = [__v_141, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_231: G = { let __values: [G; 10] = [__v_113, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_232: G = G::from_u64(1);
+                        let __v_233: G = G::from_u64(1);
+                        let __v_234: G = { let __values: [G; 3] = [__v_232, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_235: G = { let __values: [G; 3] = [__v_112, __v_231, __v_234]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_236: G = G::from_u64(0);
+                        let __v_237: G = G::from_u64(1);
+                        let __v_238: G = G::from_u64(1);
+                        let __v_239: G = { let __values: [G; 3] = [__v_237, __v_238, __v_238]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_240: G = { let __values: [G; 3] = [__v_236, __v_25, __v_239]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+                        let __v_241: G = __r_arr[0];
+                        let __v_242: G = G::from_u64(1);
+                        if (__v_241 != __v_242) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_107, __v_108, __v_17, __v_20, __v_13, __v_23, __v_25, __v_109, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                        let __v_243: G = __r_arr[0];
+                        let __v_244: G = __r_arr[1];
+                        let __ret: [G; OUT_168] = [__v_243, __v_244];
+                        if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_169: usize = 25;
+const IN_169: usize = 25;
+const OUT_169: usize = 1;
+fn aiur_fn_169(
+  inp: [G; IN_169],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_169], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    match __v_1.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __v_28: G = G::from_u64(0);
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        match __v_29.as_canonical_u64() {
+          _ => {
+            let __v_31: G = G::from_u64(0);
+            let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_25, __v_0, __v_20, __v_19, __v_31, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+            let __v_32: G = __r_arr[0];
+            let __v_33: G = G::from_u64(1);
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __v_35: G = __r_arr[1];
+            match __v_34.as_canonical_u64() {
+              _ => {
+                let __v_36: G = G::from_u64(0);
+                let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_32, __v_0, __v_20, __v_19, __v_36, __v_18, __v_15, __v_16, __v_17, __v_34, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+                let __v_37: G = __r_arr[0];
+                let __v_38: G = G::from_u64(2);
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                let __v_39: G = __r_arr[0];
+                let __v_40: G = __r_arr[1];
+                match __v_39.as_canonical_u64() {
+                  _ => {
+                    let __v_41: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_37, __v_0, __v_20, __v_19, __v_41, __v_18, __v_15, __v_16, __v_17, __v_39, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+                    let __v_42: G = __r_arr[0];
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_42, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+                    let __v_43: G = __r_arr[0];
+                    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_43, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+                    let __v_44: G = __r_arr[0];
+                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_43.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+                    let __v_45: G = __loaded[0];
+                    let __v_46: G = __loaded[1];
+                    let __v_47: G = __loaded[2];
+                    let __v_48: G = __loaded[3];
+                    let __v_49: G = __loaded[4];
+                    let __v_50: G = __loaded[5];
+                    let __v_51: G = __loaded[6];
+                    match __v_45.as_canonical_u64() {
+                      0u64 => {
+                        match __v_46.as_canonical_u64() {
+                          _ => {
+                            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_49, __v_50, __v_21, __v_22, __v_2, __v_0, __v_20, __v_51, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                            let __v_52: G = __r_arr[0];
+                            let __v_53: G = __r_arr[1];
+                            let __v_54: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_23, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                            let __v_55: G = __r_arr[0];
+                            let __v_56: G = __r_arr[1];
+                            let __v_57: G = (__v_55 - __v_52);
+                            let __v_58: G = (__v_56 - __v_53);
+                            let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                            let __v_59: G = __r_arr[0];
+                            let __v_60: G = (__v_59 - __v_24);
+                            let __v_61: G = G::from_bool((__v_60 == G::ZERO));
+                            let __v_62: G = G::from_u64(1);
+                            if (__v_61 != __v_62) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+                            let __v_63: G = __r_arr[0];
+                            let __v_64: G = G::from_u64(3);
+                            let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+                            let __v_65: G = __r_arr[0];
+                            let __v_66: G = (__v_64 + __v_65);
+                            let __v_67: G = (__v_63 - __v_66);
+                            let __v_68: G = G::from_bool((__v_67 == G::ZERO));
+                            let __v_69: G = G::from_u64(1);
+                            if (__v_68 != __v_69) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                            let __v_70: G = __r_arr[0];
+                            let __v_71: G = (__v_70 - __v_18);
+                            let __v_72: G = G::from_bool((__v_71 == G::ZERO));
+                            let __v_73: G = G::from_u64(1);
+                            if (__v_72 != __v_73) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+                            let __v_74: G = __r_arr[0];
+                            let __v_75: G = G::from_u64(1);
+                            if (__v_74 != __v_75) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                            let __v_76: G = __r_arr[0];
+                            let __v_77: G = (__v_76 - __v_18);
+                            let __v_78: G = G::from_bool((__v_77 == G::ZERO));
+                            let __v_79: G = G::from_u64(1);
+                            if (__v_78 != __v_79) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_79.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_11, __v_34, __v_27, __v_0, __v_35, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+                            let __v_80: G = __r_arr[0];
+                            let __v_81: G = G::from_u64(1);
+                            if (__v_80 != __v_81) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                            let __v_82: G = __r_arr[0];
+                            let __v_83: G = (__v_82 - __v_18);
+                            let __v_84: G = G::from_bool((__v_83 == G::ZERO));
+                            let __v_85: G = G::from_u64(1);
+                            if (__v_84 != __v_85) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_85.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+                            let __v_86: G = __r_arr[0];
+                            let __v_87: G = G::from_u64(1);
+                            if (__v_86 != __v_87) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_87.as_canonical_u64(), msg: None });
+                            }
+                            let __v_88: G = (__v_46 - __v_20);
+                            let __v_89: G = G::from_bool((__v_88 == G::ZERO));
+                            let __v_90: G = G::from_u64(1);
+                            if (__v_89 != __v_90) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: None });
+                            }
+                            let __v_91: G = G::from_bool((__v_57 == G::ZERO));
+                            let __v_92: G = G::from_bool((__v_58 == G::ZERO));
+                            let __v_93: G = (__v_91 * __v_92);
+                            let __v_94: G = G::from_u64(1);
+                            if (__v_93 != __v_94) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: None });
+                            }
+                            let __v_95: G = G::from_u64(1);
+                            let __ret: [G; OUT_169] = [__v_95];
+                            if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_170: usize = 25;
+const IN_170: usize = 25;
+const OUT_170: usize = 1;
+fn aiur_fn_170(
+  inp: [G; IN_170],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_170], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_25: G = __loaded[0];
+    let __v_26: G = __loaded[1];
+    let __v_27: G = __loaded[2];
+    let __v_28: G = __loaded[3];
+    match __v_25.as_canonical_u64() {
+      1u64 => {
+        let __v_29: G = G::from_u64(1);
+        let __ret: [G; OUT_170] = [__v_29];
+        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } };
+        let __v_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = __r_arr[2];
+        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+        let __v_32: G = __r_arr[0];
+        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __v_33: G = __r_arr[0];
+        let __ret: [G; OUT_170] = [__v_33];
+        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_171: usize = 34;
+const IN_171: usize = 34;
+const OUT_171: usize = 1;
+fn aiur_fn_171(
+  inp: [G; IN_171],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_171], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    match __v_27.as_canonical_u64() {
+      _ => {
+        match __v_6.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __v_35: G = G::from_u64(1);
+            let __v_36: G = G::from_u64(1);
+            let __v_37: G = { let __values: [G; 3] = [__v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() {
+  0u64 => {
+    break '__mc_0 [__v_37];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __v_38: G = __r_arr[0];
+    break '__mc_0 [__v_38];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+  },
+}
+ };
+            let __v_38: G = __mc_out___mc_0[0];
+            let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+            let __v_39: G = __r_arr[0];
+            let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_2, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+            let __v_40: G = __r_arr[0];
+            let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+            let __v_41: G = __r_arr[0];
+            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+            let __v_42: G = __r_arr[0];
+            let __v_43: G = G::from_u64(1);
+            let __v_44: G = G::from_u64(1);
+            let __v_45: G = { let __values: [G; 3] = [__v_43, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_42, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+            let __v_46: G = __r_arr[0];
+            let __v_47: G = __r_arr[1];
+            let __v_48: G = __r_arr[2];
+            let __v_49: G = __r_arr[3];
+            let __v_50: G = __r_arr[4];
+            let __v_51: G = __r_arr[5];
+            let __v_52: G = __r_arr[6];
+            let __v_53: G = __r_arr[7];
+            let __v_54: G = __r_arr[8];
+            let __v_55: G = __r_arr[9];
+            let __v_56: G = __r_arr[10];
+            let __v_57: G = __r_arr[11];
+            let __v_58: G = __r_arr[12];
+            let __v_59: G = __r_arr[13];
+            let __v_60: G = __r_arr[14];
+            let __v_61: G = __r_arr[15];
+            let __v_62: G = __r_arr[16];
+            let __v_63: G = __r_arr[17];
+            let __v_64: G = G::from_u64(256);
+            let __v_65: G = (__v_64 * __v_47);
+            let __v_66: G = G::from_u64(65536);
+            let __v_67: G = (__v_66 * __v_48);
+            let __v_68: G = G::from_u64(16777216);
+            let __v_69: G = (__v_68 * __v_49);
+            let __v_70: G = G::from_u64(4294967296);
+            let __v_71: G = (__v_70 * __v_50);
+            let __v_72: G = G::from_u64(1099511627776);
+            let __v_73: G = (__v_72 * __v_51);
+            let __v_74: G = G::from_u64(281474976710656);
+            let __v_75: G = (__v_74 * __v_52);
+            let __v_76: G = G::from_u64(72057594037927936);
+            let __v_77: G = (__v_76 * __v_53);
+            let __v_78: G = (__v_75 + __v_77);
+            let __v_79: G = (__v_73 + __v_78);
+            let __v_80: G = (__v_71 + __v_79);
+            let __v_81: G = (__v_69 + __v_80);
+            let __v_82: G = (__v_67 + __v_81);
+            let __v_83: G = (__v_65 + __v_82);
+            let __v_84: G = (__v_46 + __v_83);
+            let __v_85: G = G::from_u64(256);
+            let __v_86: G = (__v_85 * __v_55);
+            let __v_87: G = G::from_u64(65536);
+            let __v_88: G = (__v_87 * __v_56);
+            let __v_89: G = G::from_u64(16777216);
+            let __v_90: G = (__v_89 * __v_57);
+            let __v_91: G = G::from_u64(4294967296);
+            let __v_92: G = (__v_91 * __v_58);
+            let __v_93: G = G::from_u64(1099511627776);
+            let __v_94: G = (__v_93 * __v_59);
+            let __v_95: G = G::from_u64(281474976710656);
+            let __v_96: G = (__v_95 * __v_60);
+            let __v_97: G = G::from_u64(72057594037927936);
+            let __v_98: G = (__v_97 * __v_61);
+            let __v_99: G = (__v_96 + __v_98);
+            let __v_100: G = (__v_94 + __v_99);
+            let __v_101: G = (__v_92 + __v_100);
+            let __v_102: G = (__v_90 + __v_101);
+            let __v_103: G = (__v_88 + __v_102);
+            let __v_104: G = (__v_86 + __v_103);
+            let __v_105: G = (__v_54 + __v_104);
+            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_62, __v_6, __v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+            let __v_106: G = __r_arr[0];
+            let __v_107: G = __r_arr[1];
+            let __v_108: G = G::from_u64(1);
+            let __v_109: G = G::from_u64(1);
+            let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_9, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+            let __v_111: G = __r_arr[0];
+            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_107, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+            let __v_112: G = __r_arr[0];
+            let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_112, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+            let __v_113: G = __r_arr[0];
+            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_113, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+            let __v_114: G = __r_arr[0];
+            let __v_115: G = __r_arr[1];
+            let __v_116: G = (__v_34 + __v_27);
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+            let __v_117: G = __r_arr[0];
+            let __v_118: G = (__v_117 - __v_34);
+            let __v_119: G = G::from_bool((__v_118 == G::ZERO));
+            let __v_120: G = G::from_u64(1);
+            if (__v_119 != __v_120) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_119.as_canonical_u64(), rhs: __v_120.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+            let __v_121: G = __r_arr[0];
+            let __v_122: G = (__v_121 - __v_31);
+            let __v_123: G = G::from_bool((__v_122 == G::ZERO));
+            let __v_124: G = G::from_u64(1);
+            if (__v_123 != __v_124) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_124.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+            let __v_125: G = __r_arr[0];
+            let __v_126: G = G::from_u64(1);
+            if (__v_125 != __v_126) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None });
+            }
+            let __v_127: G = G::from_u64(33);
+            let __v_128: G = { let __a_val = __v_116.as_canonical_u64(); let __b_val = __v_127.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+            let __v_129: G = G::from_u64(1);
+            if (__v_128 != __v_129) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_128.as_canonical_u64(), rhs: __v_129.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_114, __v_115, __v_8, __v_84, __v_105, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_116, __v_106, __v_6, __v_9, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+            let __v_130: G = __r_arr[0];
+            let __ret: [G; OUT_171] = [__v_130];
+            if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_172: usize = 33;
+const IN_172: usize = 33;
+const OUT_172: usize = 1;
+fn aiur_fn_172(
+  inp: [G; IN_172],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_172], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_34: G = __r_arr[0];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_35: G = __r_arr[0];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_36: G = __r_arr[0];
+    let __ret: [G; OUT_172] = [__v_36];
+    if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_161: usize = 3;
-const IN_161: usize = 3;
-const OUT_161: usize = 2;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+const INPUT_SIZE_173: usize = 2;
+const IN_173: usize = 2;
+const OUT_173: usize = 1;
+fn aiur_fn_173(
+  inp: [G; IN_173],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_161], ExecError> {
+) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_173] = [__v_1];
+        if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
       0u64 => {
-        let __ret: [G; OUT_161] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
+        let __v_11: G = __loaded[6];
+        let __v_12: G = __loaded[7];
+        let __v_13: G = __loaded[8];
+        let __v_14: G = __loaded[9];
+        let __v_15: G = __loaded[10];
+        let __v_16: G = __loaded[11];
+        let __v_17: G = __loaded[12];
+        let __v_18: G = __loaded[13];
+        let __v_19: G = __loaded[14];
+        let __v_20: G = __loaded[15];
+        let __v_21: G = __loaded[16];
+        let __v_22: G = __loaded[17];
+        let __v_23: G = __loaded[18];
+        let __v_24: G = __loaded[19];
+        let __v_25: G = __loaded[20];
+        let __v_26: G = __loaded[21];
+        let __v_27: G = __loaded[22];
+        let __v_28: G = __loaded[23];
+        let __v_29: G = __loaded[24];
+        let __v_30: G = __loaded[25];
+        let __v_31: G = __loaded[26];
+        let __v_32: G = __loaded[27];
+        let __v_33: G = __loaded[28];
+        let __v_34: G = __loaded[29];
+        let __v_35: G = __loaded[30];
+        let __v_36: G = __loaded[31];
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+        let __v_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __v_38: G = __r_arr[0];
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __v_39: G = __r_arr[0];
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __v_40: G = __r_arr[0];
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __v_41: G = __r_arr[0];
+        let __ret: [G; OUT_173] = [__v_41];
+        if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __v_3: G = (__v_0 * __v_0);
-        let __v_4: G = G::from_u64(7);
-        let __v_5: G = (__v_1 * __v_1);
-        let __v_6: G = (__v_4 * __v_5);
-        let __v_7: G = (__v_3 + __v_6);
-        let __v_8: G = (__v_0 * __v_1);
-        let __v_9: G = (__v_1 * __v_0);
-        let __v_10: G = (__v_8 + __v_9);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = (__v_2 - __v_11);
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_161] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_162: usize = 1;
-const IN_162: usize = 1;
-const OUT_162: usize = 1;
-fn aiur_fn_162(
-  inp: [G; IN_162],
+const INPUT_SIZE_174: usize = 2;
+const IN_174: usize = 2;
+const OUT_174: usize = 1;
+fn aiur_fn_174(
+  inp: [G; IN_174],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_162], ExecError> {
+) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_162] = [__v_1];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      32u64 => {
-        let __v_1: G = G::from_u64(1753635133440165772);
-        let __ret: [G; OUT_162] = [__v_1];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_1: G = G::from_u64(1);
-        let __v_2: G = (__v_0 + __v_1);
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __v_4: G = (__v_3 * __v_3);
-        let __ret: [G; OUT_162] = [__v_4];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __ret: [G; OUT_174] = [__v_6];
+    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_163: usize = 3;
-const IN_163: usize = 3;
-const OUT_163: usize = 2;
-fn aiur_fn_163(
-  inp: [G; IN_163],
+const INPUT_SIZE_175: usize = 2;
+const IN_175: usize = 2;
+const OUT_175: usize = 1;
+fn aiur_fn_175(
+  inp: [G; IN_175],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_163], ExecError> {
+) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = (__v_3 - __v_5);
-    let __v_8: G = (__v_4 - __v_6);
-    let __ret: [G; OUT_163] = [__v_7, __v_8];
-    if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_2: G = G::from_bool((__v_0 == G::ZERO));
+    let __v_3: G = G::from_bool((__v_1 == G::ZERO));
+    let __v_4: G = (__v_2 * __v_3);
+    let __ret: [G; OUT_175] = [__v_4];
+    if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_164: usize = 1;
-const IN_164: usize = 1;
-const OUT_164: usize = 1;
-fn aiur_fn_164(
-  inp: [G; IN_164],
+const INPUT_SIZE_176: usize = 1;
+const IN_176: usize = 1;
+const OUT_176: usize = 1;
+fn aiur_fn_176(
+  inp: [G; IN_176],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_164], ExecError> {
+) -> Result<[G; OUT_176], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_164] = [__v_1];
-        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_176] = [__v_5];
+        if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_9: G = G::from_bool((__v_2 == G::ZERO));
+            let __v_10: G = G::from_bool((__v_3 == G::ZERO));
+            let __v_11: G = (__v_9 * __v_10);
+            let __ret: [G; OUT_176] = [__v_11];
+            if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __ret: [G; OUT_176] = [__v_9];
+            if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
       _ => {
-        let __v_1: G = G::from_u64(2);
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = (__v_0 - __v_2);
-        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = (__v_1 * __v_4);
-        let __ret: [G; OUT_164] = [__v_5];
-        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_165: usize = 3;
-const IN_165: usize = 3;
-const OUT_165: usize = 8;
-fn aiur_fn_165(
-  inp: [G; IN_165],
+const INPUT_SIZE_177: usize = 2;
+const IN_177: usize = 2;
+const OUT_177: usize = 1;
+fn aiur_fn_177(
+  inp: [G; IN_177],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_165], ExecError> {
+) -> Result<[G; OUT_177], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = (__v_3 - __v_5);
-    let __v_8: G = (__v_4 - __v_6);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = g_inverse_value(__v_9);
-    let __v_11: G = (__v_9 * __v_10);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = (__v_11 - __v_12);
-    let __v_14: G = (__v_9 * __v_13);
-    let __v_15: G = G::from_u64(0);
-    if (__v_14 != __v_15) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
-    }
-    let __v_16: G = (__v_10 * __v_13);
-    let __v_17: G = G::from_u64(0);
-    if (__v_16 != __v_17) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
-    }
-    let __v_18: G = G::from_u64(1);
-    let __v_19: G = G::from_u64(0);
-    let __v_20: G = (__v_0 - __v_18);
-    let __v_21: G = (__v_1 - __v_19);
-    let __v_22: G = (__v_20 * __v_20);
-    let __v_23: G = G::from_u64(7);
-    let __v_24: G = (__v_21 * __v_21);
-    let __v_25: G = (__v_23 * __v_24);
-    let __v_26: G = (__v_22 - __v_25);
-    let __v_27: G = g_inverse_value(__v_26);
-    let __v_28: G = (__v_26 * __v_27);
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = (__v_28 - __v_29);
-    let __v_31: G = (__v_26 * __v_30);
-    let __v_32: G = G::from_u64(0);
-    if (__v_31 != __v_32) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_177] = [__v_4];
+        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __ret: [G; OUT_177] = [__v_1];
+        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
     }
-    let __v_33: G = (__v_27 * __v_30);
+  })
+}
+
+const INPUT_SIZE_178: usize = 9;
+const IN_178: usize = 9;
+const OUT_178: usize = 9;
+fn aiur_fn_178(
+  inp: [G; IN_178],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_178], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(109);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = G::from_u64(117);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = G::from_u64(108);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(116);
+    let __v_22: G = G::from_u64(0);
+    let __v_23: G = G::from_u64(105);
+    let __v_24: G = G::from_u64(0);
+    let __v_25: G = G::from_u64(45);
+    let __v_26: G = G::from_u64(0);
+    let __v_27: G = G::from_u64(115);
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = G::from_u64(116);
+    let __v_30: G = G::from_u64(0);
+    let __v_31: G = G::from_u64(97);
+    let __v_32: G = G::from_u64(0);
+    let __v_33: G = G::from_u64(114);
     let __v_34: G = G::from_u64(0);
-    if (__v_33 != __v_34) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None });
-    }
-    let __v_35: G = (__v_20 * __v_27);
+    let __v_35: G = G::from_u64(107);
     let __v_36: G = G::from_u64(0);
-    let __v_37: G = (__v_36 - __v_21);
-    let __v_38: G = (__v_37 * __v_27);
-    let __v_39: G = (__v_7 * __v_35);
-    let __v_40: G = G::from_u64(7);
-    let __v_41: G = (__v_8 * __v_38);
-    let __v_42: G = (__v_40 * __v_41);
-    let __v_43: G = (__v_39 + __v_42);
-    let __v_44: G = (__v_7 * __v_38);
-    let __v_45: G = (__v_8 * __v_35);
-    let __v_46: G = (__v_44 + __v_45);
-    let __v_47: G = G::from_u64(0);
-    let __v_48: G = (__v_0 - __v_10);
-    let __v_49: G = (__v_1 - __v_47);
-    let __v_50: G = (__v_48 * __v_48);
-    let __v_51: G = G::from_u64(7);
-    let __v_52: G = (__v_49 * __v_49);
-    let __v_53: G = (__v_51 * __v_52);
-    let __v_54: G = (__v_50 - __v_53);
-    let __v_55: G = g_inverse_value(__v_54);
-    let __v_56: G = (__v_54 * __v_55);
+    let __v_37: G = G::from_u64(47);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(118);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(48);
+    let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_56: G = G::from_u64(1);
     let __v_57: G = G::from_u64(1);
-    let __v_58: G = (__v_56 - __v_57);
-    let __v_59: G = (__v_54 * __v_58);
-    let __v_60: G = G::from_u64(0);
-    if (__v_59 != __v_60) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
-    }
-    let __v_61: G = (__v_55 * __v_58);
-    let __v_62: G = G::from_u64(0);
-    if (__v_61 != __v_62) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
-    }
-    let __v_63: G = (__v_48 * __v_55);
-    let __v_64: G = G::from_u64(0);
-    let __v_65: G = (__v_64 - __v_49);
-    let __v_66: G = (__v_65 * __v_55);
-    let __v_67: G = (__v_7 * __v_63);
-    let __v_68: G = G::from_u64(7);
-    let __v_69: G = (__v_8 * __v_66);
-    let __v_70: G = (__v_68 * __v_69);
-    let __v_71: G = (__v_67 + __v_70);
-    let __v_72: G = (__v_7 * __v_66);
-    let __v_73: G = (__v_8 * __v_63);
-    let __v_74: G = (__v_72 + __v_73);
-    let __v_75: G = G::from_u64(0);
-    let __v_76: G = (__v_0 - __v_10);
-    let __v_77: G = (__v_1 - __v_75);
-    let __v_78: G = (__v_7 * __v_7);
-    let __v_79: G = G::from_u64(7);
-    let __v_80: G = (__v_8 * __v_8);
-    let __v_81: G = (__v_79 * __v_80);
-    let __v_82: G = (__v_78 - __v_81);
-    let __v_83: G = g_inverse_value(__v_82);
-    let __v_84: G = (__v_82 * __v_83);
-    let __v_85: G = G::from_u64(1);
-    let __v_86: G = (__v_84 - __v_85);
-    let __v_87: G = (__v_82 * __v_86);
-    let __v_88: G = G::from_u64(0);
-    if (__v_87 != __v_88) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
-    }
-    let __v_89: G = (__v_83 * __v_86);
-    let __v_90: G = G::from_u64(0);
-    if (__v_89 != __v_90) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: None });
-    }
-    let __v_91: G = (__v_7 * __v_83);
-    let __v_92: G = G::from_u64(0);
-    let __v_93: G = (__v_92 - __v_8);
-    let __v_94: G = (__v_93 * __v_83);
-    let __ret: [G; OUT_165] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94];
-    if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+    let __v_59: G = __r_arr[0];
+    let __v_60: G = __r_arr[1];
+    let __v_61: G = __r_arr[2];
+    let __v_62: G = __r_arr[3];
+    let __v_63: G = __r_arr[4];
+    let __v_64: G = __r_arr[5];
+    let __v_65: G = __r_arr[6];
+    let __v_66: G = __r_arr[7];
+    let __v_67: G = __r_arr[8];
+    let __v_68: G = __r_arr[9];
+    let __v_69: G = __r_arr[10];
+    let __v_70: G = __r_arr[11];
+    let __v_71: G = __r_arr[12];
+    let __v_72: G = __r_arr[13];
+    let __v_73: G = __r_arr[14];
+    let __v_74: G = __r_arr[15];
+    let __v_75: G = __r_arr[16];
+    let __v_76: G = __r_arr[17];
+    let __v_77: G = G::from_u64(1);
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_80: G = __r_arr[0];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_81: G = __r_arr[0];
+    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+    let __v_82: G = __r_arr[0];
+    let __v_83: G = G::from_u64(1);
+    let __v_84: G = G::from_u64(1);
+    let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+    let __v_86: G = __r_arr[0];
+    let __v_87: G = __r_arr[1];
+    let __v_88: G = __r_arr[2];
+    let __v_89: G = __r_arr[3];
+    let __v_90: G = __r_arr[4];
+    let __v_91: G = __r_arr[5];
+    let __v_92: G = __r_arr[6];
+    let __v_93: G = __r_arr[7];
+    let __v_94: G = __r_arr[8];
+    let __v_95: G = __r_arr[9];
+    let __v_96: G = __r_arr[10];
+    let __v_97: G = __r_arr[11];
+    let __v_98: G = __r_arr[12];
+    let __v_99: G = __r_arr[13];
+    let __v_100: G = __r_arr[14];
+    let __v_101: G = __r_arr[15];
+    let __v_102: G = __r_arr[16];
+    let __v_103: G = __r_arr[17];
+    let __v_104: G = G::from_u64(1);
+    let __v_105: G = G::from_u64(1);
+    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_107: G = __r_arr[0];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_108: G = __r_arr[0];
+    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+    let __v_109: G = __r_arr[0];
+    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+    let __v_110: G = __r_arr[0];
+    let __v_111: G = G::from_u64(1);
+    let __v_112: G = G::from_u64(1);
+    let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+    let __v_114: G = __r_arr[0];
+    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+    let __v_115: G = __r_arr[0];
+    let __v_116: G = G::from_u64(1);
+    let __v_117: G = G::from_u64(1);
+    let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+    let __v_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __v_121: G = __r_arr[2];
+    let __v_122: G = __r_arr[3];
+    let __v_123: G = __r_arr[4];
+    let __v_124: G = __r_arr[5];
+    let __v_125: G = __r_arr[6];
+    let __v_126: G = __r_arr[7];
+    let __v_127: G = __r_arr[8];
+    let __v_128: G = __r_arr[9];
+    let __v_129: G = __r_arr[10];
+    let __v_130: G = __r_arr[11];
+    let __v_131: G = __r_arr[12];
+    let __v_132: G = __r_arr[13];
+    let __v_133: G = __r_arr[14];
+    let __v_134: G = __r_arr[15];
+    let __v_135: G = __r_arr[16];
+    let __v_136: G = __r_arr[17];
+    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+    let __v_137: G = __r_arr[0];
+    let __v_138: G = G::from_u64(1);
+    let __v_139: G = G::from_u64(1);
+    let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+    let __v_141: G = __r_arr[0];
+    let __v_142: G = __r_arr[1];
+    let __v_143: G = __r_arr[2];
+    let __v_144: G = __r_arr[3];
+    let __v_145: G = __r_arr[4];
+    let __v_146: G = __r_arr[5];
+    let __v_147: G = __r_arr[6];
+    let __v_148: G = __r_arr[7];
+    let __v_149: G = __r_arr[8];
+    let __v_150: G = __r_arr[9];
+    let __v_151: G = __r_arr[10];
+    let __v_152: G = __r_arr[11];
+    let __v_153: G = __r_arr[12];
+    let __v_154: G = __r_arr[13];
+    let __v_155: G = __r_arr[14];
+    let __v_156: G = __r_arr[15];
+    let __v_157: G = __r_arr[16];
+    let __v_158: G = __r_arr[17];
+    let __v_159: G = G::from_u64(256);
+    let __v_160: G = (__v_159 * __v_60);
+    let __v_161: G = G::from_u64(65536);
+    let __v_162: G = (__v_161 * __v_61);
+    let __v_163: G = G::from_u64(16777216);
+    let __v_164: G = (__v_163 * __v_62);
+    let __v_165: G = G::from_u64(4294967296);
+    let __v_166: G = (__v_165 * __v_63);
+    let __v_167: G = G::from_u64(1099511627776);
+    let __v_168: G = (__v_167 * __v_64);
+    let __v_169: G = G::from_u64(281474976710656);
+    let __v_170: G = (__v_169 * __v_65);
+    let __v_171: G = G::from_u64(72057594037927936);
+    let __v_172: G = (__v_171 * __v_66);
+    let __v_173: G = (__v_170 + __v_172);
+    let __v_174: G = (__v_168 + __v_173);
+    let __v_175: G = (__v_166 + __v_174);
+    let __v_176: G = (__v_164 + __v_175);
+    let __v_177: G = (__v_162 + __v_176);
+    let __v_178: G = (__v_160 + __v_177);
+    let __v_179: G = (__v_59 + __v_178);
+    let __v_180: G = G::from_u64(256);
+    let __v_181: G = (__v_180 * __v_68);
+    let __v_182: G = G::from_u64(65536);
+    let __v_183: G = (__v_182 * __v_69);
+    let __v_184: G = G::from_u64(16777216);
+    let __v_185: G = (__v_184 * __v_70);
+    let __v_186: G = G::from_u64(4294967296);
+    let __v_187: G = (__v_186 * __v_71);
+    let __v_188: G = G::from_u64(1099511627776);
+    let __v_189: G = (__v_188 * __v_72);
+    let __v_190: G = G::from_u64(281474976710656);
+    let __v_191: G = (__v_190 * __v_73);
+    let __v_192: G = G::from_u64(72057594037927936);
+    let __v_193: G = (__v_192 * __v_74);
+    let __v_194: G = (__v_191 + __v_193);
+    let __v_195: G = (__v_189 + __v_194);
+    let __v_196: G = (__v_187 + __v_195);
+    let __v_197: G = (__v_185 + __v_196);
+    let __v_198: G = (__v_183 + __v_197);
+    let __v_199: G = (__v_181 + __v_198);
+    let __v_200: G = (__v_67 + __v_199);
+    let __v_201: G = G::from_u64(256);
+    let __v_202: G = (__v_201 * __v_87);
+    let __v_203: G = G::from_u64(65536);
+    let __v_204: G = (__v_203 * __v_88);
+    let __v_205: G = G::from_u64(16777216);
+    let __v_206: G = (__v_205 * __v_89);
+    let __v_207: G = G::from_u64(4294967296);
+    let __v_208: G = (__v_207 * __v_90);
+    let __v_209: G = G::from_u64(1099511627776);
+    let __v_210: G = (__v_209 * __v_91);
+    let __v_211: G = G::from_u64(281474976710656);
+    let __v_212: G = (__v_211 * __v_92);
+    let __v_213: G = G::from_u64(72057594037927936);
+    let __v_214: G = (__v_213 * __v_93);
+    let __v_215: G = (__v_212 + __v_214);
+    let __v_216: G = (__v_210 + __v_215);
+    let __v_217: G = (__v_208 + __v_216);
+    let __v_218: G = (__v_206 + __v_217);
+    let __v_219: G = (__v_204 + __v_218);
+    let __v_220: G = (__v_202 + __v_219);
+    let __v_221: G = (__v_86 + __v_220);
+    let __v_222: G = G::from_u64(256);
+    let __v_223: G = (__v_222 * __v_95);
+    let __v_224: G = G::from_u64(65536);
+    let __v_225: G = (__v_224 * __v_96);
+    let __v_226: G = G::from_u64(16777216);
+    let __v_227: G = (__v_226 * __v_97);
+    let __v_228: G = G::from_u64(4294967296);
+    let __v_229: G = (__v_228 * __v_98);
+    let __v_230: G = G::from_u64(1099511627776);
+    let __v_231: G = (__v_230 * __v_99);
+    let __v_232: G = G::from_u64(281474976710656);
+    let __v_233: G = (__v_232 * __v_100);
+    let __v_234: G = G::from_u64(72057594037927936);
+    let __v_235: G = (__v_234 * __v_101);
+    let __v_236: G = (__v_233 + __v_235);
+    let __v_237: G = (__v_231 + __v_236);
+    let __v_238: G = (__v_229 + __v_237);
+    let __v_239: G = (__v_227 + __v_238);
+    let __v_240: G = (__v_225 + __v_239);
+    let __v_241: G = (__v_223 + __v_240);
+    let __v_242: G = (__v_94 + __v_241);
+    let __v_243: G = G::from_u64(256);
+    let __v_244: G = (__v_243 * __v_120);
+    let __v_245: G = G::from_u64(65536);
+    let __v_246: G = (__v_245 * __v_121);
+    let __v_247: G = G::from_u64(16777216);
+    let __v_248: G = (__v_247 * __v_122);
+    let __v_249: G = G::from_u64(4294967296);
+    let __v_250: G = (__v_249 * __v_123);
+    let __v_251: G = G::from_u64(1099511627776);
+    let __v_252: G = (__v_251 * __v_124);
+    let __v_253: G = G::from_u64(281474976710656);
+    let __v_254: G = (__v_253 * __v_125);
+    let __v_255: G = G::from_u64(72057594037927936);
+    let __v_256: G = (__v_255 * __v_126);
+    let __v_257: G = (__v_254 + __v_256);
+    let __v_258: G = (__v_252 + __v_257);
+    let __v_259: G = (__v_250 + __v_258);
+    let __v_260: G = (__v_248 + __v_259);
+    let __v_261: G = (__v_246 + __v_260);
+    let __v_262: G = (__v_244 + __v_261);
+    let __v_263: G = (__v_119 + __v_262);
+    let __v_264: G = G::from_u64(256);
+    let __v_265: G = (__v_264 * __v_128);
+    let __v_266: G = G::from_u64(65536);
+    let __v_267: G = (__v_266 * __v_129);
+    let __v_268: G = G::from_u64(16777216);
+    let __v_269: G = (__v_268 * __v_130);
+    let __v_270: G = G::from_u64(4294967296);
+    let __v_271: G = (__v_270 * __v_131);
+    let __v_272: G = G::from_u64(1099511627776);
+    let __v_273: G = (__v_272 * __v_132);
+    let __v_274: G = G::from_u64(281474976710656);
+    let __v_275: G = (__v_274 * __v_133);
+    let __v_276: G = G::from_u64(72057594037927936);
+    let __v_277: G = (__v_276 * __v_134);
+    let __v_278: G = (__v_275 + __v_277);
+    let __v_279: G = (__v_273 + __v_278);
+    let __v_280: G = (__v_271 + __v_279);
+    let __v_281: G = (__v_269 + __v_280);
+    let __v_282: G = (__v_267 + __v_281);
+    let __v_283: G = (__v_265 + __v_282);
+    let __v_284: G = (__v_127 + __v_283);
+    let __v_285: G = G::from_u64(256);
+    let __v_286: G = (__v_285 * __v_142);
+    let __v_287: G = G::from_u64(65536);
+    let __v_288: G = (__v_287 * __v_143);
+    let __v_289: G = G::from_u64(16777216);
+    let __v_290: G = (__v_289 * __v_144);
+    let __v_291: G = G::from_u64(4294967296);
+    let __v_292: G = (__v_291 * __v_145);
+    let __v_293: G = G::from_u64(1099511627776);
+    let __v_294: G = (__v_293 * __v_146);
+    let __v_295: G = G::from_u64(281474976710656);
+    let __v_296: G = (__v_295 * __v_147);
+    let __v_297: G = G::from_u64(72057594037927936);
+    let __v_298: G = (__v_297 * __v_148);
+    let __v_299: G = (__v_296 + __v_298);
+    let __v_300: G = (__v_294 + __v_299);
+    let __v_301: G = (__v_292 + __v_300);
+    let __v_302: G = (__v_290 + __v_301);
+    let __v_303: G = (__v_288 + __v_302);
+    let __v_304: G = (__v_286 + __v_303);
+    let __v_305: G = (__v_141 + __v_304);
+    let __v_306: G = G::from_u64(256);
+    let __v_307: G = (__v_306 * __v_150);
+    let __v_308: G = G::from_u64(65536);
+    let __v_309: G = (__v_308 * __v_151);
+    let __v_310: G = G::from_u64(16777216);
+    let __v_311: G = (__v_310 * __v_152);
+    let __v_312: G = G::from_u64(4294967296);
+    let __v_313: G = (__v_312 * __v_153);
+    let __v_314: G = G::from_u64(1099511627776);
+    let __v_315: G = (__v_314 * __v_154);
+    let __v_316: G = G::from_u64(281474976710656);
+    let __v_317: G = (__v_316 * __v_155);
+    let __v_318: G = G::from_u64(72057594037927936);
+    let __v_319: G = (__v_318 * __v_156);
+    let __v_320: G = (__v_317 + __v_319);
+    let __v_321: G = (__v_315 + __v_320);
+    let __v_322: G = (__v_313 + __v_321);
+    let __v_323: G = (__v_311 + __v_322);
+    let __v_324: G = (__v_309 + __v_323);
+    let __v_325: G = (__v_307 + __v_324);
+    let __v_326: G = (__v_149 + __v_325);
+    let __ret: [G; OUT_178] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157];
+    if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_166: usize = 23;
-const IN_166: usize = 23;
-const OUT_166: usize = 1;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+const INPUT_SIZE_179: usize = 23;
+const IN_179: usize = 23;
+const OUT_179: usize = 1;
+fn aiur_fn_179(
+  inp: [G; IN_179],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_166], ExecError> {
+) -> Result<[G; OUT_179], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15412,52 +15661,52 @@ fn aiur_fn_166(
     let __v_22: G = inp[22];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __v_24: G = G::from_bool((__v_23 == G::ZERO));
         let __v_25: G = G::from_u64(0);
         if (__v_24 != __v_25) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         if (__v_26 != __v_23) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
         if (__v_27 != __v_23) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         if (__v_28 != __v_23) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
         let __v_30: G = G::from_u64(1);
         if (__v_29 != __v_30) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
         }
         let __v_31: G = G::from_u64(1);
-        let __ret: [G; OUT_166] = [__v_31];
-        if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_179] = [__v_31];
+        if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_167: usize = 6;
-const IN_167: usize = 6;
-const OUT_167: usize = 2;
-fn aiur_fn_167(
-  inp: [G; IN_167],
+const INPUT_SIZE_180: usize = 6;
+const IN_180: usize = 6;
+const OUT_180: usize = 2;
+fn aiur_fn_180(
+  inp: [G; IN_180],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_167], ExecError> {
+) -> Result<[G; OUT_180], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15469,27 +15718,27 @@ fn aiur_fn_167(
     let __v_7: G = G::from_u64(7);
     let __v_8: G = (__v_1 * __v_3);
     let __v_9: G = (__v_7 * __v_8);
-    let __v_10: G = (__v_6 + __v_9);
-    let __v_11: G = (__v_0 * __v_3);
-    let __v_12: G = (__v_1 * __v_2);
-    let __v_13: G = (__v_11 + __v_12);
-    let __v_14: G = (__v_10 + __v_4);
+    let __v_10: G = (__v_0 * __v_3);
+    let __v_11: G = (__v_1 * __v_2);
+    let __v_12: G = (__v_6 + __v_9);
+    let __v_13: G = (__v_10 + __v_11);
+    let __v_14: G = (__v_12 + __v_4);
     let __v_15: G = (__v_13 + __v_5);
-    let __ret: [G; OUT_167] = [__v_14, __v_15];
-    if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_180] = [__v_14, __v_15];
+    if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_168: usize = 4;
-const IN_168: usize = 4;
-const OUT_168: usize = 2;
-fn aiur_fn_168(
-  inp: [G; IN_168],
+const INPUT_SIZE_181: usize = 4;
+const IN_181: usize = 4;
+const OUT_181: usize = 2;
+fn aiur_fn_181(
+  inp: [G; IN_181],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_168], ExecError> {
+) -> Result<[G; OUT_181], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15501,27 +15750,27 @@ fn aiur_fn_168(
     let __v_7: G = G::from_u64(7);
     let __v_8: G = (__v_3 * __v_5);
     let __v_9: G = (__v_7 * __v_8);
-    let __v_10: G = (__v_6 + __v_9);
-    let __v_11: G = (__v_2 * __v_5);
-    let __v_12: G = (__v_3 * __v_4);
-    let __v_13: G = (__v_11 + __v_12);
-    let __v_14: G = (__v_0 + __v_10);
+    let __v_10: G = (__v_2 * __v_5);
+    let __v_11: G = (__v_3 * __v_4);
+    let __v_12: G = (__v_6 + __v_9);
+    let __v_13: G = (__v_10 + __v_11);
+    let __v_14: G = (__v_0 + __v_12);
     let __v_15: G = (__v_1 + __v_13);
-    let __ret: [G; OUT_168] = [__v_14, __v_15];
-    if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_181] = [__v_14, __v_15];
+    if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_169: usize = 1;
-const IN_169: usize = 1;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
+const INPUT_SIZE_182: usize = 1;
+const IN_182: usize = 1;
+const OUT_182: usize = 1;
+fn aiur_fn_182(
+  inp: [G; IN_182],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_169], ExecError> {
+) -> Result<[G; OUT_182], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -15534,8 +15783,8 @@ fn aiur_fn_169(
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_169] = [__v_7];
-        if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_182] = [__v_7];
+        if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -15547,14 +15796,14 @@ fn aiur_fn_169(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_169] = [__v_13];
-            if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_182] = [__v_13];
+            if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -15569,15 +15818,15 @@ fn aiur_fn_169(
   })
 }
 
-const INPUT_SIZE_170: usize = 15;
-const IN_170: usize = 15;
-const OUT_170: usize = 2;
-fn aiur_fn_170(
-  inp: [G; IN_170],
+const INPUT_SIZE_183: usize = 15;
+const IN_183: usize = 15;
+const OUT_183: usize = 2;
+fn aiur_fn_183(
+  inp: [G; IN_183],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_170], ExecError> {
+) -> Result<[G; OUT_183], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15594,7 +15843,7 @@ fn aiur_fn_170(
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
     let __v_17: G = __r_arr[2];
@@ -15602,8 +15851,8 @@ fn aiur_fn_170(
     match __v_15.as_canonical_u64() {
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __ret: [G; OUT_170] = [__v_16, __v_19];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_16, __v_19];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -15611,133 +15860,133 @@ fn aiur_fn_170(
         let __v_20: G = (__v_16 + __v_19);
         match __v_20.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __ret: [G; OUT_170] = [__v_19, __v_20];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_19, __v_20];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_170] = [__v_9, __v_10];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_9, __v_10];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_170] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_11, __v_12];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_170] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_13, __v_14];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = (__v_19 + __v_21);
         let __v_24: G = (__v_20 + __v_22);
-        let __ret: [G; OUT_170] = [__v_23, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_23, __v_24];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = (__v_19 - __v_21);
         let __v_24: G = (__v_20 - __v_22);
-        let __ret: [G; OUT_170] = [__v_23, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_23, __v_24];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = (__v_19 * __v_21);
         let __v_24: G = G::from_u64(7);
         let __v_25: G = (__v_20 * __v_22);
         let __v_26: G = (__v_24 * __v_25);
-        let __v_27: G = (__v_23 + __v_26);
-        let __v_28: G = (__v_19 * __v_22);
-        let __v_29: G = (__v_20 * __v_21);
-        let __v_30: G = (__v_28 + __v_29);
-        let __ret: [G; OUT_170] = [__v_27, __v_30];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_27: G = (__v_19 * __v_22);
+        let __v_28: G = (__v_20 * __v_21);
+        let __v_29: G = (__v_23 + __v_26);
+        let __v_30: G = (__v_27 + __v_28);
+        let __ret: [G; OUT_183] = [__v_29, __v_30];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = G::from_u64(0);
         let __v_22: G = (__v_21 - __v_19);
         let __v_23: G = G::from_u64(0);
         let __v_24: G = (__v_23 - __v_20);
-        let __ret: [G; OUT_170] = [__v_22, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_22, __v_24];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15747,15 +15996,15 @@ fn aiur_fn_170(
   })
 }
 
-const INPUT_SIZE_171: usize = 19;
-const IN_171: usize = 19;
-const OUT_171: usize = 2;
-fn aiur_fn_171(
-  inp: [G; IN_171],
+const INPUT_SIZE_184: usize = 19;
+const IN_184: usize = 19;
+const OUT_184: usize = 2;
+fn aiur_fn_184(
+  inp: [G; IN_184],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_171], ExecError> {
+) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15782,22 +16031,22 @@ fn aiur_fn_171(
     let __v_21: G = __loaded[2];
     match __v_19.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_171] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_184] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         let __v_23: G = __r_arr[1];
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
-        let __ret: [G; OUT_171] = [__v_26, __v_27];
-        if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_184] = [__v_26, __v_27];
+        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15807,15 +16056,15 @@ fn aiur_fn_171(
   })
 }
 
-const INPUT_SIZE_172: usize = 8;
-const IN_172: usize = 8;
-const OUT_172: usize = 4;
-fn aiur_fn_172(
-  inp: [G; IN_172],
+const INPUT_SIZE_185: usize = 8;
+const IN_185: usize = 8;
+const OUT_185: usize = 4;
+fn aiur_fn_185(
+  inp: [G; IN_185],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_172], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15829,63 +16078,63 @@ fn aiur_fn_172(
     let __v_9: G = G::from_u64(7);
     let __v_10: G = (__v_1 * __v_5);
     let __v_11: G = (__v_9 * __v_10);
-    let __v_12: G = (__v_8 + __v_11);
-    let __v_13: G = (__v_0 * __v_5);
-    let __v_14: G = (__v_1 * __v_4);
-    let __v_15: G = (__v_13 + __v_14);
+    let __v_12: G = (__v_0 * __v_5);
+    let __v_13: G = (__v_1 * __v_4);
+    let __v_14: G = (__v_8 + __v_11);
+    let __v_15: G = (__v_12 + __v_13);
     let __v_16: G = G::from_u64(7);
     let __v_17: G = G::from_u64(0);
     let __v_18: G = (__v_2 * __v_6);
     let __v_19: G = G::from_u64(7);
     let __v_20: G = (__v_3 * __v_7);
     let __v_21: G = (__v_19 * __v_20);
-    let __v_22: G = (__v_18 + __v_21);
-    let __v_23: G = (__v_2 * __v_7);
-    let __v_24: G = (__v_3 * __v_6);
-    let __v_25: G = (__v_23 + __v_24);
-    let __v_26: G = (__v_16 * __v_22);
+    let __v_22: G = (__v_2 * __v_7);
+    let __v_23: G = (__v_3 * __v_6);
+    let __v_24: G = (__v_18 + __v_21);
+    let __v_25: G = (__v_22 + __v_23);
+    let __v_26: G = (__v_16 * __v_24);
     let __v_27: G = G::from_u64(7);
     let __v_28: G = (__v_17 * __v_25);
     let __v_29: G = (__v_27 * __v_28);
-    let __v_30: G = (__v_26 + __v_29);
-    let __v_31: G = (__v_16 * __v_25);
-    let __v_32: G = (__v_17 * __v_22);
-    let __v_33: G = (__v_31 + __v_32);
+    let __v_30: G = (__v_16 * __v_25);
+    let __v_31: G = (__v_17 * __v_24);
+    let __v_32: G = (__v_26 + __v_29);
+    let __v_33: G = (__v_30 + __v_31);
     let __v_34: G = (__v_0 * __v_6);
     let __v_35: G = G::from_u64(7);
     let __v_36: G = (__v_1 * __v_7);
     let __v_37: G = (__v_35 * __v_36);
-    let __v_38: G = (__v_34 + __v_37);
-    let __v_39: G = (__v_0 * __v_7);
-    let __v_40: G = (__v_1 * __v_6);
-    let __v_41: G = (__v_39 + __v_40);
+    let __v_38: G = (__v_0 * __v_7);
+    let __v_39: G = (__v_1 * __v_6);
+    let __v_40: G = (__v_34 + __v_37);
+    let __v_41: G = (__v_38 + __v_39);
     let __v_42: G = (__v_2 * __v_4);
     let __v_43: G = G::from_u64(7);
     let __v_44: G = (__v_3 * __v_5);
     let __v_45: G = (__v_43 * __v_44);
-    let __v_46: G = (__v_42 + __v_45);
-    let __v_47: G = (__v_2 * __v_5);
-    let __v_48: G = (__v_3 * __v_4);
-    let __v_49: G = (__v_47 + __v_48);
-    let __v_50: G = (__v_12 + __v_30);
+    let __v_46: G = (__v_2 * __v_5);
+    let __v_47: G = (__v_3 * __v_4);
+    let __v_48: G = (__v_42 + __v_45);
+    let __v_49: G = (__v_46 + __v_47);
+    let __v_50: G = (__v_14 + __v_32);
     let __v_51: G = (__v_15 + __v_33);
-    let __v_52: G = (__v_38 + __v_46);
+    let __v_52: G = (__v_40 + __v_48);
     let __v_53: G = (__v_41 + __v_49);
-    let __ret: [G; OUT_172] = [__v_50, __v_51, __v_52, __v_53];
-    if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_185] = [__v_50, __v_51, __v_52, __v_53];
+    if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_173: usize = 19;
-const IN_173: usize = 19;
-const OUT_173: usize = 4;
-fn aiur_fn_173(
-  inp: [G; IN_173],
+const INPUT_SIZE_186: usize = 19;
+const IN_186: usize = 19;
+const OUT_186: usize = 4;
+fn aiur_fn_186(
+  inp: [G; IN_186],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_173], ExecError> {
+) -> Result<[G; OUT_186], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15916,28 +16165,28 @@ fn aiur_fn_173(
         let __v_23: G = G::from_u64(0);
         let __v_24: G = G::from_u64(0);
         let __v_25: G = G::from_u64(0);
-        let __ret: [G; OUT_173] = [__v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_186] = [__v_22, __v_23, __v_24, __v_25];
+        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         let __v_23: G = __r_arr[1];
         let __v_24: G = __r_arr[2];
         let __v_25: G = __r_arr[3];
-        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
         let __v_29: G = __r_arr[3];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
         let __v_31: G = __r_arr[1];
         let __v_32: G = (__v_26 + __v_30);
         let __v_33: G = (__v_27 + __v_31);
-        let __ret: [G; OUT_173] = [__v_32, __v_33, __v_28, __v_29];
-        if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_186] = [__v_32, __v_33, __v_28, __v_29];
+        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15947,15 +16196,15 @@ fn aiur_fn_173(
   })
 }
 
-const INPUT_SIZE_174: usize = 44;
-const IN_174: usize = 44;
-const OUT_174: usize = 2;
-fn aiur_fn_174(
-  inp: [G; IN_174],
+const INPUT_SIZE_187: usize = 44;
+const IN_187: usize = 44;
+const OUT_187: usize = 2;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_174], ExecError> {
+) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16008,14 +16257,14 @@ fn aiur_fn_174(
     let __v_47: G = __loaded[3];
     match __v_44.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_174] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_187] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         match __v_45.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
             let __v_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
             let __v_50: G = __r_arr[2];
@@ -16024,10 +16273,10 @@ fn aiur_fn_174(
             let __v_53: G = (__v_49 + __v_23);
             let __v_54: G = (__v_50 + __v_24);
             let __v_55: G = (__v_51 + __v_25);
-            let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
             let __v_56: G = __r_arr[0];
             let __v_57: G = __r_arr[1];
-            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
             let __v_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
             let __v_60: G = __r_arr[2];
@@ -16036,23 +16285,23 @@ fn aiur_fn_174(
             let __v_63: G = G::from_u64(7);
             let __v_64: G = (__v_57 * __v_11);
             let __v_65: G = (__v_63 * __v_64);
-            let __v_66: G = (__v_62 + __v_65);
-            let __v_67: G = (__v_56 * __v_11);
-            let __v_68: G = (__v_57 * __v_10);
-            let __v_69: G = (__v_67 + __v_68);
-            let __v_70: G = (__v_58 + __v_66);
+            let __v_66: G = (__v_56 * __v_11);
+            let __v_67: G = (__v_57 * __v_10);
+            let __v_68: G = (__v_62 + __v_65);
+            let __v_69: G = (__v_66 + __v_67);
+            let __v_70: G = (__v_58 + __v_68);
             let __v_71: G = (__v_59 + __v_69);
             let __v_72: G = (__v_56 * __v_12);
             let __v_73: G = G::from_u64(7);
             let __v_74: G = (__v_57 * __v_13);
             let __v_75: G = (__v_73 * __v_74);
-            let __v_76: G = (__v_72 + __v_75);
-            let __v_77: G = (__v_56 * __v_13);
-            let __v_78: G = (__v_57 * __v_12);
-            let __v_79: G = (__v_77 + __v_78);
-            let __v_80: G = (__v_60 + __v_76);
+            let __v_76: G = (__v_56 * __v_13);
+            let __v_77: G = (__v_57 * __v_12);
+            let __v_78: G = (__v_72 + __v_75);
+            let __v_79: G = (__v_76 + __v_77);
+            let __v_80: G = (__v_60 + __v_78);
             let __v_81: G = (__v_61 + __v_79);
-            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
             let __v_82: G = __r_arr[0];
             let __v_83: G = __r_arr[1];
             let __v_84: G = __r_arr[2];
@@ -16063,23 +16312,23 @@ fn aiur_fn_174(
             match __v_88.as_canonical_u64() {
               0u64 => {
                 let __v_89: G = (__v_7 + __v_7);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                 let __v_90: G = __r_arr[0];
                 let __v_91: G = __r_arr[1];
                 let __v_92: G = G::from_u64(1);
                 let __v_93: G = (__v_7 + __v_92);
                 let __v_94: G = (__v_7 + __v_93);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                 let __v_95: G = __r_arr[0];
                 let __v_96: G = __r_arr[1];
                 let __v_97: G = G::from_u64(0);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                 let __v_98: G = __r_arr[0];
                 let __v_99: G = __r_arr[1];
                 let __v_100: G = (__v_98 + __v_18);
                 let __v_101: G = (__v_99 + __v_19);
                 let __v_102: G = G::from_u64(1);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                 let __v_103: G = __r_arr[0];
                 let __v_104: G = __r_arr[1];
                 let __v_105: G = (__v_103 + __v_20);
@@ -16088,23 +16337,23 @@ fn aiur_fn_174(
                 let __v_108: G = (__v_101 - __v_91);
                 let __v_109: G = (__v_105 - __v_95);
                 let __v_110: G = (__v_106 - __v_96);
-                let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
                 let __v_111: G = __r_arr[0];
                 let __v_112: G = __r_arr[1];
                 let __v_113: G = __r_arr[2];
                 let __v_114: G = __r_arr[3];
                 let __v_115: G = (__v_111 - __v_70);
                 let __v_116: G = (__v_112 - __v_71);
-                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                 let __v_117: G = __r_arr[0];
                 let __v_118: G = __r_arr[1];
                 let __v_119: G = (__v_113 - __v_80);
                 let __v_120: G = (__v_114 - __v_81);
-                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                 let __v_121: G = __r_arr[0];
                 let __v_122: G = __r_arr[1];
-                let __ret: [G; OUT_174] = [__v_121, __v_122];
-                if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_187] = [__v_121, __v_122];
+                if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -16113,44 +16362,44 @@ fn aiur_fn_174(
                 match __v_90.as_canonical_u64() {
                   0u64 => {
                     let __v_91: G = (__v_7 + __v_7);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                     let __v_92: G = __r_arr[0];
                     let __v_93: G = __r_arr[1];
                     let __v_94: G = G::from_u64(1);
                     let __v_95: G = (__v_7 + __v_94);
                     let __v_96: G = (__v_7 + __v_95);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                     let __v_97: G = __r_arr[0];
                     let __v_98: G = __r_arr[1];
                     let __v_99: G = G::from_u64(2);
                     let __v_100: G = (__v_7 + __v_99);
                     let __v_101: G = (__v_7 + __v_100);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                     let __v_102: G = __r_arr[0];
                     let __v_103: G = __r_arr[1];
                     let __v_104: G = G::from_u64(3);
                     let __v_105: G = (__v_7 + __v_104);
                     let __v_106: G = (__v_7 + __v_105);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                     let __v_107: G = __r_arr[0];
                     let __v_108: G = __r_arr[1];
                     let __v_109: G = (__v_102 - __v_92);
                     let __v_110: G = (__v_103 - __v_93);
                     let __v_111: G = (__v_107 - __v_97);
                     let __v_112: G = (__v_108 - __v_98);
-                    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
                     let __v_113: G = __r_arr[0];
                     let __v_114: G = __r_arr[1];
                     let __v_115: G = __r_arr[2];
                     let __v_116: G = __r_arr[3];
                     let __v_117: G = (__v_113 - __v_70);
                     let __v_118: G = (__v_114 - __v_71);
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                     let __v_119: G = __r_arr[0];
                     let __v_120: G = __r_arr[1];
                     let __v_121: G = (__v_115 - __v_80);
                     let __v_122: G = (__v_116 - __v_81);
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                     let __v_123: G = __r_arr[0];
                     let __v_124: G = __r_arr[1];
                     let __v_125: G = G::from_u64(1);
@@ -16165,11 +16414,11 @@ fn aiur_fn_174(
                     let __v_134: G = G::from_u64(0);
                     let __v_135: G = G::from_u64(0);
                     let __v_136: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
                     let __v_137: G = __r_arr[0];
                     let __v_138: G = __r_arr[1];
-                    let __ret: [G; OUT_174] = [__v_137, __v_138];
-                    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_187] = [__v_137, __v_138];
+                    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -16177,11 +16426,11 @@ fn aiur_fn_174(
                     let __v_92: G = (__v_5 + __v_91);
                     let __v_93: G = G::from_u64(1);
                     let __v_94: G = (__v_8 - __v_93);
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
                     let __v_95: G = __r_arr[0];
                     let __v_96: G = __r_arr[1];
-                    let __ret: [G; OUT_174] = [__v_95, __v_96];
-                    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_187] = [__v_95, __v_96];
+                    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -16197,15 +16446,15 @@ fn aiur_fn_174(
   })
 }
 
-const INPUT_SIZE_175: usize = 28;
-const IN_175: usize = 28;
-const OUT_175: usize = 2;
-fn aiur_fn_175(
-  inp: [G; IN_175],
+const INPUT_SIZE_188: usize = 28;
+const IN_188: usize = 28;
+const OUT_188: usize = 2;
+fn aiur_fn_188(
+  inp: [G; IN_188],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_175], ExecError> {
+) -> Result<[G; OUT_188], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16237,7 +16486,7 @@ fn aiur_fn_175(
     let __v_27: G = inp[27];
     let __v_28: G = G::from_u64(0);
     let __v_29: G = G::from_u64(0);
-    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
     let __v_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = G::from_u64(0);
@@ -16255,18 +16504,18 @@ fn aiur_fn_175(
     let __v_44: G = G::from_u64(7);
     let __v_45: G = (__v_41 * __v_42);
     let __v_46: G = (__v_44 * __v_45);
-    let __v_47: G = (__v_43 + __v_46);
-    let __v_48: G = (__v_40 * __v_42);
-    let __v_49: G = (__v_41 * __v_27);
-    let __v_50: G = (__v_48 + __v_49);
-    let __v_51: G = (__v_21 * __v_47);
+    let __v_47: G = (__v_40 * __v_42);
+    let __v_48: G = (__v_41 * __v_27);
+    let __v_49: G = (__v_43 + __v_46);
+    let __v_50: G = (__v_47 + __v_48);
+    let __v_51: G = (__v_21 * __v_49);
     let __v_52: G = G::from_u64(7);
     let __v_53: G = (__v_22 * __v_50);
     let __v_54: G = (__v_52 * __v_53);
-    let __v_55: G = (__v_51 + __v_54);
-    let __v_56: G = (__v_21 * __v_50);
-    let __v_57: G = (__v_22 * __v_47);
-    let __v_58: G = (__v_56 + __v_57);
+    let __v_55: G = (__v_21 * __v_50);
+    let __v_56: G = (__v_22 * __v_49);
+    let __v_57: G = (__v_51 + __v_54);
+    let __v_58: G = (__v_55 + __v_56);
     let __v_59: G = (__v_18 - __v_16);
     let __v_60: G = (__v_39 - __v_37);
     let __v_61: G = G::from_u64(0);
@@ -16274,18 +16523,18 @@ fn aiur_fn_175(
     let __v_63: G = G::from_u64(7);
     let __v_64: G = (__v_60 * __v_61);
     let __v_65: G = (__v_63 * __v_64);
-    let __v_66: G = (__v_62 + __v_65);
-    let __v_67: G = (__v_59 * __v_61);
-    let __v_68: G = (__v_60 * __v_27);
-    let __v_69: G = (__v_67 + __v_68);
-    let __v_70: G = (__v_21 * __v_66);
+    let __v_66: G = (__v_59 * __v_61);
+    let __v_67: G = (__v_60 * __v_27);
+    let __v_68: G = (__v_62 + __v_65);
+    let __v_69: G = (__v_66 + __v_67);
+    let __v_70: G = (__v_21 * __v_68);
     let __v_71: G = G::from_u64(7);
     let __v_72: G = (__v_22 * __v_69);
     let __v_73: G = (__v_71 * __v_72);
-    let __v_74: G = (__v_70 + __v_73);
-    let __v_75: G = (__v_21 * __v_69);
-    let __v_76: G = (__v_22 * __v_66);
-    let __v_77: G = (__v_75 + __v_76);
+    let __v_74: G = (__v_21 * __v_69);
+    let __v_75: G = (__v_22 * __v_68);
+    let __v_76: G = (__v_70 + __v_73);
+    let __v_77: G = (__v_74 + __v_75);
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_78: G = __loaded[0];
     let __v_79: G = __loaded[1];
@@ -16294,42 +16543,42 @@ fn aiur_fn_175(
     match __v_78.as_canonical_u64() {
       1u64 => {
         let __v_82: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __v_83: G = __r_arr[0];
         let __v_84: G = __r_arr[1];
         let __v_85: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __v_86: G = __r_arr[0];
         let __v_87: G = __r_arr[1];
         let __v_88: G = (__v_83 - __v_86);
         let __v_89: G = (__v_84 - __v_87);
-        let __v_90: G = (__v_88 + __v_55);
+        let __v_90: G = (__v_88 + __v_57);
         let __v_91: G = (__v_89 + __v_58);
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
         let __v_92: G = __r_arr[0];
         let __v_93: G = __r_arr[1];
         let __v_94: G = G::from_u64(1);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __v_95: G = __r_arr[0];
         let __v_96: G = __r_arr[1];
         let __v_97: G = G::from_u64(1);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __v_98: G = __r_arr[0];
         let __v_99: G = __r_arr[1];
         let __v_100: G = (__v_95 - __v_98);
         let __v_101: G = (__v_96 - __v_99);
-        let __v_102: G = (__v_100 + __v_74);
+        let __v_102: G = (__v_100 + __v_76);
         let __v_103: G = (__v_101 + __v_77);
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
         let __v_104: G = __r_arr[0];
         let __v_105: G = __r_arr[1];
-        let __ret: [G; OUT_175] = [__v_104, __v_105];
-        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_188] = [__v_104, __v_105];
+        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_82: G = G::from_u64(0);
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
         let __v_83: G = __r_arr[0];
         let __v_84: G = G::from_u64(0);
         let __v_85: G = G::from_u64(1);
@@ -16340,11 +16589,11 @@ fn aiur_fn_175(
         let __v_90: G = G::from_u64(0);
         let __v_91: G = G::from_u64(0);
         let __v_92: G = G::from_u64(0);
-        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_57, __v_58, __v_76, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
         let __v_93: G = __r_arr[0];
         let __v_94: G = __r_arr[1];
-        let __ret: [G; OUT_175] = [__v_93, __v_94];
-        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_188] = [__v_93, __v_94];
+        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16354,15 +16603,15 @@ fn aiur_fn_175(
   })
 }
 
-const INPUT_SIZE_176: usize = 8;
-const IN_176: usize = 8;
-const OUT_176: usize = 1;
-fn aiur_fn_176(
-  inp: [G; IN_176],
+const INPUT_SIZE_189: usize = 8;
+const IN_189: usize = 8;
+const OUT_189: usize = 1;
+fn aiur_fn_189(
+  inp: [G; IN_189],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_176], ExecError> {
+) -> Result<[G; OUT_189], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16399,21 +16648,21 @@ fn aiur_fn_176(
     let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_176] = [__v_34];
-    if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_189] = [__v_34];
+    if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_177: usize = 5;
-const IN_177: usize = 5;
-const OUT_177: usize = 2;
-fn aiur_fn_177(
-  inp: [G; IN_177],
+const INPUT_SIZE_190: usize = 5;
+const IN_190: usize = 5;
+const OUT_190: usize = 2;
+fn aiur_fn_190(
+  inp: [G; IN_190],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_177], ExecError> {
+) -> Result<[G; OUT_190], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16429,8 +16678,8 @@ fn aiur_fn_177(
       1u64 => {
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_177] = [__v_9, __v_10];
-        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_190] = [__v_9, __v_10];
+        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -16438,25 +16687,25 @@ fn aiur_fn_177(
         let __v_10: G = G::from_u64(7);
         let __v_11: G = (__v_4 * __v_7);
         let __v_12: G = (__v_10 * __v_11);
-        let __v_13: G = (__v_9 + __v_12);
-        let __v_14: G = (__v_3 * __v_7);
-        let __v_15: G = (__v_4 * __v_6);
-        let __v_16: G = (__v_14 + __v_15);
+        let __v_13: G = (__v_3 * __v_7);
+        let __v_14: G = (__v_4 * __v_6);
+        let __v_15: G = (__v_9 + __v_12);
+        let __v_16: G = (__v_13 + __v_14);
         let __v_17: G = (__v_3 * __v_1);
         let __v_18: G = G::from_u64(7);
         let __v_19: G = (__v_4 * __v_2);
         let __v_20: G = (__v_18 * __v_19);
-        let __v_21: G = (__v_17 + __v_20);
-        let __v_22: G = (__v_3 * __v_2);
-        let __v_23: G = (__v_4 * __v_1);
-        let __v_24: G = (__v_22 + __v_23);
-        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = (__v_3 * __v_2);
+        let __v_22: G = (__v_4 * __v_1);
+        let __v_23: G = (__v_17 + __v_20);
+        let __v_24: G = (__v_21 + __v_22);
+        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_8, __v_1, __v_2, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = __r_arr[1];
-        let __v_27: G = (__v_13 + __v_25);
+        let __v_27: G = (__v_15 + __v_25);
         let __v_28: G = (__v_16 + __v_26);
-        let __ret: [G; OUT_177] = [__v_27, __v_28];
-        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_190] = [__v_27, __v_28];
+        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16466,145 +16715,145 @@ fn aiur_fn_177(
   })
 }
 
-const INPUT_SIZE_178: usize = 1;
-const IN_178: usize = 1;
-const OUT_178: usize = 1;
-fn aiur_fn_178(
-  inp: [G; IN_178],
+const INPUT_SIZE_191: usize = 1;
+const IN_191: usize = 1;
+const OUT_191: usize = 1;
+fn aiur_fn_191(
+  inp: [G; IN_191],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_178], ExecError> {
+) -> Result<[G; OUT_191], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
         let __v_1: G = G::from_u64(4);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
         let __v_1: G = G::from_u64(4);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
         let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
         let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       8u64 => {
         let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       9u64 => {
         let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       10u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       11u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       12u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       13u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       14u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       15u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       16u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       17u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(32);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_179: usize = 4;
-const IN_179: usize = 4;
-const OUT_179: usize = 2;
-fn aiur_fn_179(
-  inp: [G; IN_179],
+const INPUT_SIZE_192: usize = 4;
+const IN_192: usize = 4;
+const OUT_192: usize = 2;
+fn aiur_fn_192(
+  inp: [G; IN_192],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_179], ExecError> {
+) -> Result<[G; OUT_192], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16618,8 +16867,8 @@ fn aiur_fn_179(
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_179] = [__v_6, __v_9];
-        if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_192] = [__v_6, __v_9];
+        if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -16631,21 +16880,21 @@ fn aiur_fn_179(
             let __v_7: G = G::from_u64(1);
             let __v_8: G = G::from_u64(1);
             let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_179] = [__v_6, __v_9];
-            if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_192] = [__v_6, __v_9];
+            if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
             let __v_5: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             let __v_7: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_179] = [__v_6, __v_8];
-            if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_192] = [__v_6, __v_8];
+            if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -16660,15 +16909,15 @@ fn aiur_fn_179(
   })
 }
 
-const INPUT_SIZE_180: usize = 20;
-const IN_180: usize = 20;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
+const INPUT_SIZE_193: usize = 20;
+const IN_193: usize = 20;
+const OUT_193: usize = 1;
+fn aiur_fn_193(
+  inp: [G; IN_193],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_180], ExecError> {
+) -> Result<[G; OUT_193], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16702,37 +16951,37 @@ fn aiur_fn_180(
     match __v_20.as_canonical_u64() {
       1u64 => {
         let __v_28: G = G::from_u64(1);
-        let __ret: [G; OUT_180] = [__v_28];
-        if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_193] = [__v_28];
+        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         match __v_21.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_32: G = __r_arr[0];
             let __v_33: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
             let __v_35: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
             let __v_38: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_39: G = __r_arr[0];
             let __v_40: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_41: G = __r_arr[0];
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
             let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() {
@@ -16757,13 +17006,13 @@ fn aiur_fn_180(
         break '__mc_0 [__v_46, __v_49];
       },
       1u64 => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
         let __v_47: G = G::from_u64(1);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_48: G = __r_arr[0];
         break '__mc_0 [__v_46, __v_48];
       },
@@ -16779,14 +17028,14 @@ fn aiur_fn_180(
  };
             let __v_44: G = __mc_out___mc_0[0];
             let __v_45: G = __mc_out___mc_0[1];
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
             let __v_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
             let __v_48: G = G::from_u64(1);
             let __v_49: G = G::from_u64(0);
             let __v_50: G = (__v_46 - __v_48);
             let __v_51: G = (__v_47 - __v_49);
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
             let __v_53: G = g_inverse_value(__v_52);
             let __v_54: G = (__v_52 * __v_53);
@@ -16825,18 +17074,18 @@ fn aiur_fn_180(
             if (__v_76 != __v_77) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
             }
-            let __v_78: G = (__v_63 * __v_70);
-            let __v_79: G = G::from_u64(0);
-            let __v_80: G = (__v_79 - __v_64);
-            let __v_81: G = (__v_80 * __v_70);
-            let __v_82: G = (__v_50 * __v_78);
+            let __v_78: G = G::from_u64(0);
+            let __v_79: G = (__v_78 - __v_64);
+            let __v_80: G = (__v_63 * __v_70);
+            let __v_81: G = (__v_79 * __v_70);
+            let __v_82: G = (__v_50 * __v_80);
             let __v_83: G = G::from_u64(7);
             let __v_84: G = (__v_51 * __v_81);
             let __v_85: G = (__v_83 * __v_84);
-            let __v_86: G = (__v_82 + __v_85);
-            let __v_87: G = (__v_50 * __v_81);
-            let __v_88: G = (__v_51 * __v_78);
-            let __v_89: G = (__v_87 + __v_88);
+            let __v_86: G = (__v_50 * __v_81);
+            let __v_87: G = (__v_51 * __v_80);
+            let __v_88: G = (__v_82 + __v_85);
+            let __v_89: G = (__v_86 + __v_87);
             let __v_90: G = G::from_u64(0);
             let __v_91: G = (__v_18 - __v_53);
             let __v_92: G = (__v_19 - __v_90);
@@ -16859,18 +17108,18 @@ fn aiur_fn_180(
             if (__v_104 != __v_105) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_105.as_canonical_u64(), msg: None });
             }
-            let __v_106: G = (__v_91 * __v_98);
-            let __v_107: G = G::from_u64(0);
-            let __v_108: G = (__v_107 - __v_92);
-            let __v_109: G = (__v_108 * __v_98);
-            let __v_110: G = (__v_50 * __v_106);
+            let __v_106: G = G::from_u64(0);
+            let __v_107: G = (__v_106 - __v_92);
+            let __v_108: G = (__v_91 * __v_98);
+            let __v_109: G = (__v_107 * __v_98);
+            let __v_110: G = (__v_50 * __v_108);
             let __v_111: G = G::from_u64(7);
             let __v_112: G = (__v_51 * __v_109);
             let __v_113: G = (__v_111 * __v_112);
-            let __v_114: G = (__v_110 + __v_113);
-            let __v_115: G = (__v_50 * __v_109);
-            let __v_116: G = (__v_51 * __v_106);
-            let __v_117: G = (__v_115 + __v_116);
+            let __v_114: G = (__v_50 * __v_109);
+            let __v_115: G = (__v_51 * __v_108);
+            let __v_116: G = (__v_110 + __v_113);
+            let __v_117: G = (__v_114 + __v_115);
             let __v_118: G = G::from_u64(0);
             let __v_119: G = (__v_18 - __v_53);
             let __v_120: G = (__v_19 - __v_118);
@@ -16893,10 +17142,10 @@ fn aiur_fn_180(
             if (__v_132 != __v_133) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_133.as_canonical_u64(), msg: None });
             }
-            let __v_134: G = (__v_50 * __v_126);
-            let __v_135: G = G::from_u64(0);
-            let __v_136: G = (__v_135 - __v_51);
-            let __v_137: G = (__v_136 * __v_126);
+            let __v_134: G = G::from_u64(0);
+            let __v_135: G = (__v_134 - __v_51);
+            let __v_136: G = (__v_50 * __v_126);
+            let __v_137: G = (__v_135 * __v_126);
             let __v_138: G = G::from_u64(0);
             let __v_139: G = G::from_u64(0);
             let __v_140: G = G::from_u64(0);
@@ -16924,9 +17173,9 @@ fn aiur_fn_180(
             let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
             let __v_165: G = __r_arr[0];
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
             let __v_166: G = __r_arr[0];
             let __v_167: G = (__v_165 * __v_166);
             let __v_168: G = g_inverse_value(__v_167);
@@ -16945,7 +17194,7 @@ fn aiur_fn_180(
             }
             let __v_176: G = G::from_u64(0);
             let __v_177: G = G::from_u64(0);
-            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_88, __v_89, __v_116, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
             let __v_178: G = __r_arr[0];
             let __v_179: G = __r_arr[1];
             let __v_180: G = G::from_u64(0);
@@ -16963,18 +17212,18 @@ fn aiur_fn_180(
             let __v_192: G = G::from_u64(7);
             let __v_193: G = (__v_189 * __v_190);
             let __v_194: G = (__v_192 * __v_193);
-            let __v_195: G = (__v_191 + __v_194);
-            let __v_196: G = (__v_188 * __v_190);
-            let __v_197: G = (__v_189 * __v_168);
-            let __v_198: G = (__v_196 + __v_197);
-            let __v_199: G = (__v_114 * __v_195);
+            let __v_195: G = (__v_188 * __v_190);
+            let __v_196: G = (__v_189 * __v_168);
+            let __v_197: G = (__v_191 + __v_194);
+            let __v_198: G = (__v_195 + __v_196);
+            let __v_199: G = (__v_116 * __v_197);
             let __v_200: G = G::from_u64(7);
             let __v_201: G = (__v_117 * __v_198);
             let __v_202: G = (__v_200 * __v_201);
-            let __v_203: G = (__v_199 + __v_202);
-            let __v_204: G = (__v_114 * __v_198);
-            let __v_205: G = (__v_117 * __v_195);
-            let __v_206: G = (__v_204 + __v_205);
+            let __v_203: G = (__v_116 * __v_198);
+            let __v_204: G = (__v_117 * __v_197);
+            let __v_205: G = (__v_199 + __v_202);
+            let __v_206: G = (__v_203 + __v_204);
             let __v_207: G = (__v_31 - __v_11);
             let __v_208: G = (__v_187 - __v_185);
             let __v_209: G = G::from_u64(0);
@@ -16982,18 +17231,18 @@ fn aiur_fn_180(
             let __v_211: G = G::from_u64(7);
             let __v_212: G = (__v_208 * __v_209);
             let __v_213: G = (__v_211 * __v_212);
-            let __v_214: G = (__v_210 + __v_213);
-            let __v_215: G = (__v_207 * __v_209);
-            let __v_216: G = (__v_208 * __v_168);
-            let __v_217: G = (__v_215 + __v_216);
-            let __v_218: G = (__v_114 * __v_214);
+            let __v_214: G = (__v_207 * __v_209);
+            let __v_215: G = (__v_208 * __v_168);
+            let __v_216: G = (__v_210 + __v_213);
+            let __v_217: G = (__v_214 + __v_215);
+            let __v_218: G = (__v_116 * __v_216);
             let __v_219: G = G::from_u64(7);
             let __v_220: G = (__v_117 * __v_217);
             let __v_221: G = (__v_219 * __v_220);
-            let __v_222: G = (__v_218 + __v_221);
-            let __v_223: G = (__v_114 * __v_217);
-            let __v_224: G = (__v_117 * __v_214);
-            let __v_225: G = (__v_223 + __v_224);
+            let __v_222: G = (__v_116 * __v_217);
+            let __v_223: G = (__v_117 * __v_216);
+            let __v_224: G = (__v_218 + __v_221);
+            let __v_225: G = (__v_222 + __v_223);
             let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_226: G = __loaded[0];
             let __v_227: G = __loaded[1];
@@ -17002,40 +17251,40 @@ fn aiur_fn_180(
             let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_226.as_canonical_u64() {
   1u64 => {
     let __v_230: G = G::from_u64(0);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
     let __v_231: G = __r_arr[0];
     let __v_232: G = __r_arr[1];
     let __v_233: G = G::from_u64(0);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
     let __v_234: G = __r_arr[0];
     let __v_235: G = __r_arr[1];
     let __v_236: G = (__v_231 - __v_234);
     let __v_237: G = (__v_232 - __v_235);
-    let __v_238: G = (__v_236 + __v_203);
+    let __v_238: G = (__v_236 + __v_205);
     let __v_239: G = (__v_237 + __v_206);
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
     let __v_240: G = __r_arr[0];
     let __v_241: G = __r_arr[1];
     let __v_242: G = G::from_u64(1);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
     let __v_243: G = __r_arr[0];
     let __v_244: G = __r_arr[1];
     let __v_245: G = G::from_u64(1);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
     let __v_246: G = __r_arr[0];
     let __v_247: G = __r_arr[1];
     let __v_248: G = (__v_243 - __v_246);
     let __v_249: G = (__v_244 - __v_247);
-    let __v_250: G = (__v_248 + __v_222);
+    let __v_250: G = (__v_248 + __v_224);
     let __v_251: G = (__v_249 + __v_225);
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
     let __v_252: G = __r_arr[0];
     let __v_253: G = __r_arr[1];
     break '__mc_1 [__v_252, __v_253];
   },
   0u64 => {
     let __v_230: G = G::from_u64(0);
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
     let __v_231: G = __r_arr[0];
     let __v_232: G = G::from_u64(0);
     let __v_233: G = G::from_u64(1);
@@ -17046,7 +17295,7 @@ fn aiur_fn_180(
     let __v_238: G = G::from_u64(0);
     let __v_239: G = G::from_u64(0);
     let __v_240: G = G::from_u64(0);
-    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_205, __v_206, __v_224, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_88, __v_89, __v_116, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
     let __v_241: G = __r_arr[0];
     let __v_242: G = __r_arr[1];
     break '__mc_1 [__v_241, __v_242];
@@ -17058,58 +17307,58 @@ fn aiur_fn_180(
  };
             let __v_230: G = __mc_out___mc_1[0];
             let __v_231: G = __mc_out___mc_1[1];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_232: G = __r_arr[0];
             let __v_233: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_234: G = __r_arr[0];
-            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
             let __v_235: G = __r_arr[0];
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
             let __v_236: G = __r_arr[0];
             let __v_237: G = __r_arr[1];
             let __v_238: G = G::from_u64(1);
             let __v_239: G = G::from_u64(0);
-            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
             let __v_240: G = __r_arr[0];
             let __v_241: G = __r_arr[1];
-            let __v_242: G = (__v_230 * __v_134);
+            let __v_242: G = (__v_230 * __v_136);
             let __v_243: G = G::from_u64(7);
             let __v_244: G = (__v_231 * __v_137);
             let __v_245: G = (__v_243 * __v_244);
-            let __v_246: G = (__v_242 + __v_245);
-            let __v_247: G = (__v_230 * __v_137);
-            let __v_248: G = (__v_231 * __v_134);
-            let __v_249: G = (__v_247 + __v_248);
-            let __v_250: G = G::from_u64(32);
-            let __v_251: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_250) } else { bytes2_less_than_value(__v_28, __v_250, record) };
-            let __v_252: G = G::from_u64(1);
-            if (__v_251 != __v_252) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None });
+            let __v_246: G = (__v_230 * __v_137);
+            let __v_247: G = (__v_231 * __v_136);
+            let __v_248: G = (__v_242 + __v_245);
+            let __v_249: G = (__v_246 + __v_247);
+            let __v_250: G = (__v_248 - __v_240);
+            let __v_251: G = (__v_249 - __v_241);
+            let __v_252: G = G::from_u64(32);
+            let __v_253: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_252) } else { bytes2_less_than_value(__v_28, __v_252, record) };
+            let __v_254: G = G::from_u64(1);
+            if (__v_253 != __v_254) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_253.as_canonical_u64(), rhs: __v_254.as_canonical_u64(), msg: None });
             }
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-            let __v_253: G = __r_arr[0];
-            let __v_254: G = (__v_253 - __v_29);
-            let __v_255: G = G::from_bool((__v_254 == G::ZERO));
-            let __v_256: G = G::from_u64(1);
-            if (__v_255 != __v_256) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_256.as_canonical_u64(), msg: None });
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+            let __v_255: G = __r_arr[0];
+            let __v_256: G = (__v_255 - __v_29);
+            let __v_257: G = G::from_bool((__v_256 == G::ZERO));
+            let __v_258: G = G::from_u64(1);
+            if (__v_257 != __v_258) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_257.as_canonical_u64(), rhs: __v_258.as_canonical_u64(), msg: None });
             }
-            let __v_257: G = (__v_246 - __v_240);
-            let __v_258: G = G::from_bool((__v_257 == G::ZERO));
-            let __v_259: G = (__v_249 - __v_241);
-            let __v_260: G = G::from_bool((__v_259 == G::ZERO));
-            let __v_261: G = (__v_258 * __v_260);
+            let __v_259: G = G::from_bool((__v_250 == G::ZERO));
+            let __v_260: G = G::from_bool((__v_251 == G::ZERO));
+            let __v_261: G = (__v_259 * __v_260);
             let __v_262: G = G::from_u64(1);
             if (__v_261 != __v_262) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_261.as_canonical_u64(), rhs: __v_262.as_canonical_u64(), msg: None });
             }
             let __v_263: G = G::from_u64(1);
             let __v_264: G = (__v_9 + __v_263);
-            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
             let __v_265: G = __r_arr[0];
-            let __ret: [G; OUT_180] = [__v_265];
-            if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_193] = [__v_265];
+            if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -17121,15 +17370,15 @@ fn aiur_fn_180(
   })
 }
 
-const INPUT_SIZE_181: usize = 3;
-const IN_181: usize = 3;
-const OUT_181: usize = 2;
-fn aiur_fn_181(
-  inp: [G; IN_181],
+const INPUT_SIZE_194: usize = 3;
+const IN_194: usize = 3;
+const OUT_194: usize = 2;
+fn aiur_fn_194(
+  inp: [G; IN_194],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_181], ExecError> {
+) -> Result<[G; OUT_194], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17149,8 +17398,8 @@ fn aiur_fn_181(
       1u64 => {
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_181] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_194] = [__v_13, __v_14];
+        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -17176,21 +17425,21 @@ fn aiur_fn_181(
         let __v_32: G = (__v_14 + __v_31);
         let __v_33: G = (__v_4 + __v_32);
         let __v_34: G = G::from_u64(0);
-        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
         let __v_35: G = __r_arr[0];
         let __v_36: G = __r_arr[1];
         let __v_37: G = (__v_0 * __v_35);
         let __v_38: G = G::from_u64(7);
         let __v_39: G = (__v_1 * __v_36);
         let __v_40: G = (__v_38 * __v_39);
-        let __v_41: G = (__v_37 + __v_40);
-        let __v_42: G = (__v_0 * __v_36);
-        let __v_43: G = (__v_1 * __v_35);
-        let __v_44: G = (__v_42 + __v_43);
-        let __v_45: G = (__v_33 + __v_41);
+        let __v_41: G = (__v_0 * __v_36);
+        let __v_42: G = (__v_1 * __v_35);
+        let __v_43: G = (__v_37 + __v_40);
+        let __v_44: G = (__v_41 + __v_42);
+        let __v_45: G = (__v_33 + __v_43);
         let __v_46: G = (__v_34 + __v_44);
-        let __ret: [G; OUT_181] = [__v_45, __v_46];
-        if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_194] = [__v_45, __v_46];
+        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -17200,15 +17449,15 @@ fn aiur_fn_181(
   })
 }
 
-const INPUT_SIZE_182: usize = 7;
-const IN_182: usize = 7;
-const OUT_182: usize = 2;
-fn aiur_fn_182(
-  inp: [G; IN_182],
+const INPUT_SIZE_195: usize = 7;
+const IN_195: usize = 7;
+const OUT_195: usize = 2;
+fn aiur_fn_195(
+  inp: [G; IN_195],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_182], ExecError> {
+) -> Result<[G; OUT_195], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17223,12 +17472,12 @@ fn aiur_fn_182(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_182] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_195] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = (__v_3 + __v_10);
@@ -17252,17 +17501,17 @@ fn aiur_fn_182(
         if (__v_25 != __v_26) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
         }
-        let __v_27: G = (__v_12 * __v_19);
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = (__v_28 - __v_13);
-        let __v_30: G = (__v_29 * __v_19);
-        let __v_31: G = (__v_0 + __v_27);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = (__v_27 - __v_13);
+        let __v_29: G = (__v_12 * __v_19);
+        let __v_30: G = (__v_28 * __v_19);
+        let __v_31: G = (__v_0 + __v_29);
         let __v_32: G = (__v_1 + __v_30);
-        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
         let __v_33: G = __r_arr[0];
         let __v_34: G = __r_arr[1];
-        let __ret: [G; OUT_182] = [__v_33, __v_34];
-        if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_195] = [__v_33, __v_34];
+        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -17272,15 +17521,15 @@ fn aiur_fn_182(
   })
 }
 
-const INPUT_SIZE_183: usize = 37;
-const IN_183: usize = 37;
-const OUT_183: usize = 1;
-fn aiur_fn_183(
-  inp: [G; IN_183],
+const INPUT_SIZE_196: usize = 37;
+const IN_196: usize = 37;
+const OUT_196: usize = 1;
+fn aiur_fn_196(
+  inp: [G; IN_196],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_183], ExecError> {
+) -> Result<[G; OUT_196], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17321,17 +17570,15 @@ fn aiur_fn_183(
     let __v_36: G = inp[36];
     match __v_0.as_canonical_u64() {
       _ => {
-        match __v_0.as_canonical_u64() {
+        match __v_12.as_canonical_u64() {
           _ => {
-            match __v_12.as_canonical_u64() {
+            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+            let __v_37: G = __r_arr[0];
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __v_38: G = __r_arr[0];
+            match __v_13.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
-                let __v_37: G = __r_arr[0];
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
-                let __v_38: G = __r_arr[0];
-                match __v_13.as_canonical_u64() {
-                  _ => {
-                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
+                let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
   0u64 => {
     let __v_39: G = G::from_u64(1);
     let __v_40: G = G::from_u64(1);
@@ -17346,357 +17593,359 @@ fn aiur_fn_183(
   },
 }
  };
-                    let __v_39: G = __mc_out___mc_0[0];
-                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_17, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                    let __v_40: G = __r_arr[0];
-                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                    let __v_41: G = __r_arr[0];
-                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_39, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                    let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_12, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                    let __v_43: G = __r_arr[0];
-                    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
-                    let __v_44: G = __r_arr[0];
-                    let __v_45: G = G::from_u64(0);
-                    let __v_46: G = G::from_u64(109);
-                    let __v_47: G = G::from_u64(0);
-                    let __v_48: G = G::from_u64(117);
-                    let __v_49: G = G::from_u64(0);
-                    let __v_50: G = G::from_u64(108);
-                    let __v_51: G = G::from_u64(0);
-                    let __v_52: G = G::from_u64(116);
-                    let __v_53: G = G::from_u64(0);
-                    let __v_54: G = G::from_u64(105);
-                    let __v_55: G = G::from_u64(0);
-                    let __v_56: G = G::from_u64(45);
-                    let __v_57: G = G::from_u64(0);
-                    let __v_58: G = G::from_u64(115);
-                    let __v_59: G = G::from_u64(0);
-                    let __v_60: G = G::from_u64(116);
-                    let __v_61: G = G::from_u64(0);
-                    let __v_62: G = G::from_u64(97);
-                    let __v_63: G = G::from_u64(0);
-                    let __v_64: G = G::from_u64(114);
-                    let __v_65: G = G::from_u64(0);
-                    let __v_66: G = G::from_u64(107);
-                    let __v_67: G = G::from_u64(0);
-                    let __v_68: G = G::from_u64(47);
-                    let __v_69: G = G::from_u64(0);
-                    let __v_70: G = G::from_u64(118);
-                    let __v_71: G = G::from_u64(0);
-                    let __v_72: G = G::from_u64(48);
-                    let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_74: G = { let __values: [G; 3] = [__v_69, __v_70, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_75: G = { let __values: [G; 3] = [__v_67, __v_68, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_76: G = { let __values: [G; 3] = [__v_65, __v_66, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_77: G = { let __values: [G; 3] = [__v_63, __v_64, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_78: G = { let __values: [G; 3] = [__v_61, __v_62, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_79: G = { let __values: [G; 3] = [__v_59, __v_60, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_80: G = { let __values: [G; 3] = [__v_57, __v_58, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_81: G = { let __values: [G; 3] = [__v_55, __v_56, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_82: G = { let __values: [G; 3] = [__v_53, __v_54, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_83: G = { let __values: [G; 3] = [__v_51, __v_52, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_84: G = { let __values: [G; 3] = [__v_49, __v_50, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_85: G = { let __values: [G; 3] = [__v_47, __v_48, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_86: G = { let __values: [G; 3] = [__v_45, __v_46, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_87: G = G::from_u64(1);
-                    let __v_88: G = G::from_u64(1);
-                    let __v_89: G = { let __values: [G; 3] = [__v_87, __v_88, __v_88]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_86, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_90: G = __r_arr[0];
-                    let __v_91: G = __r_arr[1];
-                    let __v_92: G = __r_arr[2];
-                    let __v_93: G = __r_arr[3];
-                    let __v_94: G = __r_arr[4];
-                    let __v_95: G = __r_arr[5];
-                    let __v_96: G = __r_arr[6];
-                    let __v_97: G = __r_arr[7];
-                    let __v_98: G = __r_arr[8];
-                    let __v_99: G = __r_arr[9];
-                    let __v_100: G = __r_arr[10];
-                    let __v_101: G = __r_arr[11];
-                    let __v_102: G = __r_arr[12];
-                    let __v_103: G = __r_arr[13];
-                    let __v_104: G = __r_arr[14];
-                    let __v_105: G = __r_arr[15];
-                    let __v_106: G = __r_arr[16];
-                    let __v_107: G = __r_arr[17];
-                    let __v_108: G = G::from_u64(1);
-                    let __v_109: G = G::from_u64(1);
-                    let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_111: G = __r_arr[0];
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_112: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_106, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_113: G = __r_arr[0];
-                    let __v_114: G = G::from_u64(1);
-                    let __v_115: G = G::from_u64(1);
-                    let __v_116: G = { let __values: [G; 3] = [__v_114, __v_115, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_113, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_117: G = __r_arr[0];
-                    let __v_118: G = __r_arr[1];
-                    let __v_119: G = __r_arr[2];
-                    let __v_120: G = __r_arr[3];
-                    let __v_121: G = __r_arr[4];
-                    let __v_122: G = __r_arr[5];
-                    let __v_123: G = __r_arr[6];
-                    let __v_124: G = __r_arr[7];
-                    let __v_125: G = __r_arr[8];
-                    let __v_126: G = __r_arr[9];
-                    let __v_127: G = __r_arr[10];
-                    let __v_128: G = __r_arr[11];
-                    let __v_129: G = __r_arr[12];
-                    let __v_130: G = __r_arr[13];
-                    let __v_131: G = __r_arr[14];
-                    let __v_132: G = __r_arr[15];
-                    let __v_133: G = __r_arr[16];
-                    let __v_134: G = __r_arr[17];
-                    let __v_135: G = G::from_u64(1);
-                    let __v_136: G = G::from_u64(1);
-                    let __v_137: G = { let __values: [G; 3] = [__v_135, __v_136, __v_136]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_138: G = __r_arr[0];
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_139: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_133, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_140: G = __r_arr[0];
-                    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_140, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                    let __v_141: G = __r_arr[0];
-                    let __v_142: G = G::from_u64(1);
-                    let __v_143: G = G::from_u64(1);
-                    let __v_144: G = { let __values: [G; 3] = [__v_142, __v_143, __v_143]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_16, __v_144]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-                    let __v_145: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_146: G = __r_arr[0];
-                    let __v_147: G = G::from_u64(1);
-                    let __v_148: G = G::from_u64(1);
-                    let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_146, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_150: G = __r_arr[0];
-                    let __v_151: G = __r_arr[1];
-                    let __v_152: G = __r_arr[2];
-                    let __v_153: G = __r_arr[3];
-                    let __v_154: G = __r_arr[4];
-                    let __v_155: G = __r_arr[5];
-                    let __v_156: G = __r_arr[6];
-                    let __v_157: G = __r_arr[7];
-                    let __v_158: G = __r_arr[8];
-                    let __v_159: G = __r_arr[9];
-                    let __v_160: G = __r_arr[10];
-                    let __v_161: G = __r_arr[11];
-                    let __v_162: G = __r_arr[12];
-                    let __v_163: G = __r_arr[13];
-                    let __v_164: G = __r_arr[14];
-                    let __v_165: G = __r_arr[15];
-                    let __v_166: G = __r_arr[16];
-                    let __v_167: G = __r_arr[17];
-                    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_166, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                    let __v_168: G = __r_arr[0];
-                    let __v_169: G = G::from_u64(1);
-                    let __v_170: G = G::from_u64(1);
-                    let __v_171: G = { let __values: [G; 3] = [__v_169, __v_170, __v_170]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_168, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_172: G = __r_arr[0];
-                    let __v_173: G = __r_arr[1];
-                    let __v_174: G = __r_arr[2];
-                    let __v_175: G = __r_arr[3];
-                    let __v_176: G = __r_arr[4];
-                    let __v_177: G = __r_arr[5];
-                    let __v_178: G = __r_arr[6];
-                    let __v_179: G = __r_arr[7];
-                    let __v_180: G = __r_arr[8];
-                    let __v_181: G = __r_arr[9];
-                    let __v_182: G = __r_arr[10];
-                    let __v_183: G = __r_arr[11];
-                    let __v_184: G = __r_arr[12];
-                    let __v_185: G = __r_arr[13];
-                    let __v_186: G = __r_arr[14];
-                    let __v_187: G = __r_arr[15];
-                    let __v_188: G = __r_arr[16];
-                    let __v_189: G = __r_arr[17];
-                    let __v_190: G = G::from_u64(256);
-                    let __v_191: G = (__v_190 * __v_91);
-                    let __v_192: G = G::from_u64(65536);
-                    let __v_193: G = (__v_192 * __v_92);
-                    let __v_194: G = G::from_u64(16777216);
-                    let __v_195: G = (__v_194 * __v_93);
-                    let __v_196: G = G::from_u64(4294967296);
-                    let __v_197: G = (__v_196 * __v_94);
-                    let __v_198: G = G::from_u64(1099511627776);
-                    let __v_199: G = (__v_198 * __v_95);
-                    let __v_200: G = G::from_u64(281474976710656);
-                    let __v_201: G = (__v_200 * __v_96);
-                    let __v_202: G = G::from_u64(72057594037927936);
-                    let __v_203: G = (__v_202 * __v_97);
-                    let __v_204: G = (__v_201 + __v_203);
-                    let __v_205: G = (__v_199 + __v_204);
-                    let __v_206: G = (__v_197 + __v_205);
-                    let __v_207: G = (__v_195 + __v_206);
-                    let __v_208: G = (__v_193 + __v_207);
-                    let __v_209: G = (__v_191 + __v_208);
-                    let __v_210: G = (__v_90 + __v_209);
-                    let __v_211: G = G::from_u64(256);
-                    let __v_212: G = (__v_211 * __v_99);
-                    let __v_213: G = G::from_u64(65536);
-                    let __v_214: G = (__v_213 * __v_100);
-                    let __v_215: G = G::from_u64(16777216);
-                    let __v_216: G = (__v_215 * __v_101);
-                    let __v_217: G = G::from_u64(4294967296);
-                    let __v_218: G = (__v_217 * __v_102);
-                    let __v_219: G = G::from_u64(1099511627776);
-                    let __v_220: G = (__v_219 * __v_103);
-                    let __v_221: G = G::from_u64(281474976710656);
-                    let __v_222: G = (__v_221 * __v_104);
-                    let __v_223: G = G::from_u64(72057594037927936);
-                    let __v_224: G = (__v_223 * __v_105);
-                    let __v_225: G = (__v_222 + __v_224);
-                    let __v_226: G = (__v_220 + __v_225);
-                    let __v_227: G = (__v_218 + __v_226);
-                    let __v_228: G = (__v_216 + __v_227);
-                    let __v_229: G = (__v_214 + __v_228);
-                    let __v_230: G = (__v_212 + __v_229);
-                    let __v_231: G = (__v_98 + __v_230);
-                    let __v_232: G = G::from_u64(256);
-                    let __v_233: G = (__v_232 * __v_118);
-                    let __v_234: G = G::from_u64(65536);
-                    let __v_235: G = (__v_234 * __v_119);
-                    let __v_236: G = G::from_u64(16777216);
-                    let __v_237: G = (__v_236 * __v_120);
-                    let __v_238: G = G::from_u64(4294967296);
-                    let __v_239: G = (__v_238 * __v_121);
-                    let __v_240: G = G::from_u64(1099511627776);
-                    let __v_241: G = (__v_240 * __v_122);
-                    let __v_242: G = G::from_u64(281474976710656);
-                    let __v_243: G = (__v_242 * __v_123);
-                    let __v_244: G = G::from_u64(72057594037927936);
-                    let __v_245: G = (__v_244 * __v_124);
-                    let __v_246: G = (__v_243 + __v_245);
-                    let __v_247: G = (__v_241 + __v_246);
-                    let __v_248: G = (__v_239 + __v_247);
-                    let __v_249: G = (__v_237 + __v_248);
-                    let __v_250: G = (__v_235 + __v_249);
-                    let __v_251: G = (__v_233 + __v_250);
-                    let __v_252: G = (__v_117 + __v_251);
-                    let __v_253: G = G::from_u64(256);
-                    let __v_254: G = (__v_253 * __v_126);
-                    let __v_255: G = G::from_u64(65536);
-                    let __v_256: G = (__v_255 * __v_127);
-                    let __v_257: G = G::from_u64(16777216);
-                    let __v_258: G = (__v_257 * __v_128);
-                    let __v_259: G = G::from_u64(4294967296);
-                    let __v_260: G = (__v_259 * __v_129);
-                    let __v_261: G = G::from_u64(1099511627776);
-                    let __v_262: G = (__v_261 * __v_130);
-                    let __v_263: G = G::from_u64(281474976710656);
-                    let __v_264: G = (__v_263 * __v_131);
-                    let __v_265: G = G::from_u64(72057594037927936);
-                    let __v_266: G = (__v_265 * __v_132);
-                    let __v_267: G = (__v_264 + __v_266);
-                    let __v_268: G = (__v_262 + __v_267);
-                    let __v_269: G = (__v_260 + __v_268);
-                    let __v_270: G = (__v_258 + __v_269);
-                    let __v_271: G = (__v_256 + __v_270);
-                    let __v_272: G = (__v_254 + __v_271);
-                    let __v_273: G = (__v_125 + __v_272);
-                    let __v_274: G = G::from_u64(256);
-                    let __v_275: G = (__v_274 * __v_151);
-                    let __v_276: G = G::from_u64(65536);
-                    let __v_277: G = (__v_276 * __v_152);
-                    let __v_278: G = G::from_u64(16777216);
-                    let __v_279: G = (__v_278 * __v_153);
-                    let __v_280: G = G::from_u64(4294967296);
-                    let __v_281: G = (__v_280 * __v_154);
-                    let __v_282: G = G::from_u64(1099511627776);
-                    let __v_283: G = (__v_282 * __v_155);
-                    let __v_284: G = G::from_u64(281474976710656);
-                    let __v_285: G = (__v_284 * __v_156);
-                    let __v_286: G = G::from_u64(72057594037927936);
-                    let __v_287: G = (__v_286 * __v_157);
-                    let __v_288: G = (__v_285 + __v_287);
-                    let __v_289: G = (__v_283 + __v_288);
-                    let __v_290: G = (__v_281 + __v_289);
-                    let __v_291: G = (__v_279 + __v_290);
-                    let __v_292: G = (__v_277 + __v_291);
-                    let __v_293: G = (__v_275 + __v_292);
-                    let __v_294: G = (__v_150 + __v_293);
-                    let __v_295: G = G::from_u64(256);
-                    let __v_296: G = (__v_295 * __v_159);
-                    let __v_297: G = G::from_u64(65536);
-                    let __v_298: G = (__v_297 * __v_160);
-                    let __v_299: G = G::from_u64(16777216);
-                    let __v_300: G = (__v_299 * __v_161);
-                    let __v_301: G = G::from_u64(4294967296);
-                    let __v_302: G = (__v_301 * __v_162);
-                    let __v_303: G = G::from_u64(1099511627776);
-                    let __v_304: G = (__v_303 * __v_163);
-                    let __v_305: G = G::from_u64(281474976710656);
-                    let __v_306: G = (__v_305 * __v_164);
-                    let __v_307: G = G::from_u64(72057594037927936);
-                    let __v_308: G = (__v_307 * __v_165);
-                    let __v_309: G = (__v_306 + __v_308);
-                    let __v_310: G = (__v_304 + __v_309);
-                    let __v_311: G = (__v_302 + __v_310);
-                    let __v_312: G = (__v_300 + __v_311);
-                    let __v_313: G = (__v_298 + __v_312);
-                    let __v_314: G = (__v_296 + __v_313);
-                    let __v_315: G = (__v_158 + __v_314);
-                    let __v_316: G = G::from_u64(256);
-                    let __v_317: G = (__v_316 * __v_173);
-                    let __v_318: G = G::from_u64(65536);
-                    let __v_319: G = (__v_318 * __v_174);
-                    let __v_320: G = G::from_u64(16777216);
-                    let __v_321: G = (__v_320 * __v_175);
-                    let __v_322: G = G::from_u64(4294967296);
-                    let __v_323: G = (__v_322 * __v_176);
-                    let __v_324: G = G::from_u64(1099511627776);
-                    let __v_325: G = (__v_324 * __v_177);
-                    let __v_326: G = G::from_u64(281474976710656);
-                    let __v_327: G = (__v_326 * __v_178);
-                    let __v_328: G = G::from_u64(72057594037927936);
-                    let __v_329: G = (__v_328 * __v_179);
-                    let __v_330: G = (__v_327 + __v_329);
-                    let __v_331: G = (__v_325 + __v_330);
-                    let __v_332: G = (__v_323 + __v_331);
-                    let __v_333: G = (__v_321 + __v_332);
-                    let __v_334: G = (__v_319 + __v_333);
-                    let __v_335: G = (__v_317 + __v_334);
-                    let __v_336: G = (__v_172 + __v_335);
-                    let __v_337: G = G::from_u64(256);
-                    let __v_338: G = (__v_337 * __v_181);
-                    let __v_339: G = G::from_u64(65536);
-                    let __v_340: G = (__v_339 * __v_182);
-                    let __v_341: G = G::from_u64(16777216);
-                    let __v_342: G = (__v_341 * __v_183);
-                    let __v_343: G = G::from_u64(4294967296);
-                    let __v_344: G = (__v_343 * __v_184);
-                    let __v_345: G = G::from_u64(1099511627776);
-                    let __v_346: G = (__v_345 * __v_185);
-                    let __v_347: G = G::from_u64(281474976710656);
-                    let __v_348: G = (__v_347 * __v_186);
-                    let __v_349: G = G::from_u64(72057594037927936);
-                    let __v_350: G = (__v_349 * __v_187);
-                    let __v_351: G = (__v_348 + __v_350);
-                    let __v_352: G = (__v_346 + __v_351);
-                    let __v_353: G = (__v_344 + __v_352);
-                    let __v_354: G = (__v_342 + __v_353);
-                    let __v_355: G = (__v_340 + __v_354);
-                    let __v_356: G = (__v_338 + __v_355);
-                    let __v_357: G = (__v_180 + __v_356);
-                    let __v_358: G = G::from_u64(0);
-                    let __v_359: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
-                    let __v_360: G = __r_arr[0];
-                    let __v_361: G = __r_arr[1];
-                    let __v_362: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_37, __v_38, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_362, __v_360, __v_361, __v_210, __v_231, __v_252, __v_273, __v_294, __v_315, __v_336, __v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-                    let __v_363: G = __r_arr[0];
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                    let __v_364: G = __r_arr[0];
+                let __v_39: G = __mc_out___mc_0[0];
+                let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+                let __v_40: G = __r_arr[0];
+                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+                let __v_41: G = __r_arr[0];
+                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_39, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+                let __v_42: G = __r_arr[0];
+                let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_12, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+                let __v_43: G = __r_arr[0];
+                let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
+                let __v_44: G = __r_arr[0];
+                let __v_45: G = G::from_u64(0);
+                let __v_46: G = G::from_u64(109);
+                let __v_47: G = G::from_u64(0);
+                let __v_48: G = G::from_u64(117);
+                let __v_49: G = G::from_u64(0);
+                let __v_50: G = G::from_u64(108);
+                let __v_51: G = G::from_u64(0);
+                let __v_52: G = G::from_u64(116);
+                let __v_53: G = G::from_u64(0);
+                let __v_54: G = G::from_u64(105);
+                let __v_55: G = G::from_u64(0);
+                let __v_56: G = G::from_u64(45);
+                let __v_57: G = G::from_u64(0);
+                let __v_58: G = G::from_u64(115);
+                let __v_59: G = G::from_u64(0);
+                let __v_60: G = G::from_u64(116);
+                let __v_61: G = G::from_u64(0);
+                let __v_62: G = G::from_u64(97);
+                let __v_63: G = G::from_u64(0);
+                let __v_64: G = G::from_u64(114);
+                let __v_65: G = G::from_u64(0);
+                let __v_66: G = G::from_u64(107);
+                let __v_67: G = G::from_u64(0);
+                let __v_68: G = G::from_u64(47);
+                let __v_69: G = G::from_u64(0);
+                let __v_70: G = G::from_u64(118);
+                let __v_71: G = G::from_u64(0);
+                let __v_72: G = G::from_u64(48);
+                let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_74: G = { let __values: [G; 3] = [__v_69, __v_70, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_75: G = { let __values: [G; 3] = [__v_67, __v_68, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_76: G = { let __values: [G; 3] = [__v_65, __v_66, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_77: G = { let __values: [G; 3] = [__v_63, __v_64, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_78: G = { let __values: [G; 3] = [__v_61, __v_62, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_79: G = { let __values: [G; 3] = [__v_59, __v_60, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_80: G = { let __values: [G; 3] = [__v_57, __v_58, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_81: G = { let __values: [G; 3] = [__v_55, __v_56, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_82: G = { let __values: [G; 3] = [__v_53, __v_54, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_83: G = { let __values: [G; 3] = [__v_51, __v_52, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_84: G = { let __values: [G; 3] = [__v_49, __v_50, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_85: G = { let __values: [G; 3] = [__v_47, __v_48, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_86: G = { let __values: [G; 3] = [__v_45, __v_46, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_87: G = G::from_u64(1);
+                let __v_88: G = G::from_u64(1);
+                let __v_89: G = { let __values: [G; 3] = [__v_87, __v_88, __v_88]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_86, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+                let __v_90: G = __r_arr[0];
+                let __v_91: G = __r_arr[1];
+                let __v_92: G = __r_arr[2];
+                let __v_93: G = __r_arr[3];
+                let __v_94: G = __r_arr[4];
+                let __v_95: G = __r_arr[5];
+                let __v_96: G = __r_arr[6];
+                let __v_97: G = __r_arr[7];
+                let __v_98: G = __r_arr[8];
+                let __v_99: G = __r_arr[9];
+                let __v_100: G = __r_arr[10];
+                let __v_101: G = __r_arr[11];
+                let __v_102: G = __r_arr[12];
+                let __v_103: G = __r_arr[13];
+                let __v_104: G = __r_arr[14];
+                let __v_105: G = __r_arr[15];
+                let __v_106: G = __r_arr[16];
+                let __v_107: G = __r_arr[17];
+                let __v_108: G = G::from_u64(1);
+                let __v_109: G = G::from_u64(1);
+                let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+                let __v_111: G = __r_arr[0];
+                let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+                let __v_112: G = __r_arr[0];
+                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_106, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+                let __v_113: G = __r_arr[0];
+                let __v_114: G = G::from_u64(1);
+                let __v_115: G = G::from_u64(1);
+                let __v_116: G = { let __values: [G; 3] = [__v_114, __v_115, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_113, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+                let __v_117: G = __r_arr[0];
+                let __v_118: G = __r_arr[1];
+                let __v_119: G = __r_arr[2];
+                let __v_120: G = __r_arr[3];
+                let __v_121: G = __r_arr[4];
+                let __v_122: G = __r_arr[5];
+                let __v_123: G = __r_arr[6];
+                let __v_124: G = __r_arr[7];
+                let __v_125: G = __r_arr[8];
+                let __v_126: G = __r_arr[9];
+                let __v_127: G = __r_arr[10];
+                let __v_128: G = __r_arr[11];
+                let __v_129: G = __r_arr[12];
+                let __v_130: G = __r_arr[13];
+                let __v_131: G = __r_arr[14];
+                let __v_132: G = __r_arr[15];
+                let __v_133: G = __r_arr[16];
+                let __v_134: G = __r_arr[17];
+                let __v_135: G = G::from_u64(1);
+                let __v_136: G = G::from_u64(1);
+                let __v_137: G = { let __values: [G; 3] = [__v_135, __v_136, __v_136]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+                let __v_138: G = __r_arr[0];
+                let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+                let __v_139: G = __r_arr[0];
+                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_133, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+                let __v_140: G = __r_arr[0];
+                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_140, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __v_141: G = __r_arr[0];
+                let __v_142: G = G::from_u64(1);
+                let __v_143: G = G::from_u64(1);
+                let __v_144: G = { let __values: [G; 3] = [__v_142, __v_143, __v_143]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_16, __v_144]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+                let __v_145: G = __r_arr[0];
+                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+                let __v_146: G = __r_arr[0];
+                let __v_147: G = G::from_u64(1);
+                let __v_148: G = G::from_u64(1);
+                let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_146, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+                let __v_150: G = __r_arr[0];
+                let __v_151: G = __r_arr[1];
+                let __v_152: G = __r_arr[2];
+                let __v_153: G = __r_arr[3];
+                let __v_154: G = __r_arr[4];
+                let __v_155: G = __r_arr[5];
+                let __v_156: G = __r_arr[6];
+                let __v_157: G = __r_arr[7];
+                let __v_158: G = __r_arr[8];
+                let __v_159: G = __r_arr[9];
+                let __v_160: G = __r_arr[10];
+                let __v_161: G = __r_arr[11];
+                let __v_162: G = __r_arr[12];
+                let __v_163: G = __r_arr[13];
+                let __v_164: G = __r_arr[14];
+                let __v_165: G = __r_arr[15];
+                let __v_166: G = __r_arr[16];
+                let __v_167: G = __r_arr[17];
+                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_166, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                let __v_168: G = __r_arr[0];
+                let __v_169: G = G::from_u64(1);
+                let __v_170: G = G::from_u64(1);
+                let __v_171: G = { let __values: [G; 3] = [__v_169, __v_170, __v_170]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_168, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+                let __v_172: G = __r_arr[0];
+                let __v_173: G = __r_arr[1];
+                let __v_174: G = __r_arr[2];
+                let __v_175: G = __r_arr[3];
+                let __v_176: G = __r_arr[4];
+                let __v_177: G = __r_arr[5];
+                let __v_178: G = __r_arr[6];
+                let __v_179: G = __r_arr[7];
+                let __v_180: G = __r_arr[8];
+                let __v_181: G = __r_arr[9];
+                let __v_182: G = __r_arr[10];
+                let __v_183: G = __r_arr[11];
+                let __v_184: G = __r_arr[12];
+                let __v_185: G = __r_arr[13];
+                let __v_186: G = __r_arr[14];
+                let __v_187: G = __r_arr[15];
+                let __v_188: G = __r_arr[16];
+                let __v_189: G = __r_arr[17];
+                let __v_190: G = G::from_u64(256);
+                let __v_191: G = (__v_190 * __v_91);
+                let __v_192: G = G::from_u64(65536);
+                let __v_193: G = (__v_192 * __v_92);
+                let __v_194: G = G::from_u64(16777216);
+                let __v_195: G = (__v_194 * __v_93);
+                let __v_196: G = G::from_u64(4294967296);
+                let __v_197: G = (__v_196 * __v_94);
+                let __v_198: G = G::from_u64(1099511627776);
+                let __v_199: G = (__v_198 * __v_95);
+                let __v_200: G = G::from_u64(281474976710656);
+                let __v_201: G = (__v_200 * __v_96);
+                let __v_202: G = G::from_u64(72057594037927936);
+                let __v_203: G = (__v_202 * __v_97);
+                let __v_204: G = (__v_201 + __v_203);
+                let __v_205: G = (__v_199 + __v_204);
+                let __v_206: G = (__v_197 + __v_205);
+                let __v_207: G = (__v_195 + __v_206);
+                let __v_208: G = (__v_193 + __v_207);
+                let __v_209: G = (__v_191 + __v_208);
+                let __v_210: G = (__v_90 + __v_209);
+                let __v_211: G = G::from_u64(256);
+                let __v_212: G = (__v_211 * __v_99);
+                let __v_213: G = G::from_u64(65536);
+                let __v_214: G = (__v_213 * __v_100);
+                let __v_215: G = G::from_u64(16777216);
+                let __v_216: G = (__v_215 * __v_101);
+                let __v_217: G = G::from_u64(4294967296);
+                let __v_218: G = (__v_217 * __v_102);
+                let __v_219: G = G::from_u64(1099511627776);
+                let __v_220: G = (__v_219 * __v_103);
+                let __v_221: G = G::from_u64(281474976710656);
+                let __v_222: G = (__v_221 * __v_104);
+                let __v_223: G = G::from_u64(72057594037927936);
+                let __v_224: G = (__v_223 * __v_105);
+                let __v_225: G = (__v_222 + __v_224);
+                let __v_226: G = (__v_220 + __v_225);
+                let __v_227: G = (__v_218 + __v_226);
+                let __v_228: G = (__v_216 + __v_227);
+                let __v_229: G = (__v_214 + __v_228);
+                let __v_230: G = (__v_212 + __v_229);
+                let __v_231: G = (__v_98 + __v_230);
+                let __v_232: G = G::from_u64(256);
+                let __v_233: G = (__v_232 * __v_118);
+                let __v_234: G = G::from_u64(65536);
+                let __v_235: G = (__v_234 * __v_119);
+                let __v_236: G = G::from_u64(16777216);
+                let __v_237: G = (__v_236 * __v_120);
+                let __v_238: G = G::from_u64(4294967296);
+                let __v_239: G = (__v_238 * __v_121);
+                let __v_240: G = G::from_u64(1099511627776);
+                let __v_241: G = (__v_240 * __v_122);
+                let __v_242: G = G::from_u64(281474976710656);
+                let __v_243: G = (__v_242 * __v_123);
+                let __v_244: G = G::from_u64(72057594037927936);
+                let __v_245: G = (__v_244 * __v_124);
+                let __v_246: G = (__v_243 + __v_245);
+                let __v_247: G = (__v_241 + __v_246);
+                let __v_248: G = (__v_239 + __v_247);
+                let __v_249: G = (__v_237 + __v_248);
+                let __v_250: G = (__v_235 + __v_249);
+                let __v_251: G = (__v_233 + __v_250);
+                let __v_252: G = (__v_117 + __v_251);
+                let __v_253: G = G::from_u64(256);
+                let __v_254: G = (__v_253 * __v_126);
+                let __v_255: G = G::from_u64(65536);
+                let __v_256: G = (__v_255 * __v_127);
+                let __v_257: G = G::from_u64(16777216);
+                let __v_258: G = (__v_257 * __v_128);
+                let __v_259: G = G::from_u64(4294967296);
+                let __v_260: G = (__v_259 * __v_129);
+                let __v_261: G = G::from_u64(1099511627776);
+                let __v_262: G = (__v_261 * __v_130);
+                let __v_263: G = G::from_u64(281474976710656);
+                let __v_264: G = (__v_263 * __v_131);
+                let __v_265: G = G::from_u64(72057594037927936);
+                let __v_266: G = (__v_265 * __v_132);
+                let __v_267: G = (__v_264 + __v_266);
+                let __v_268: G = (__v_262 + __v_267);
+                let __v_269: G = (__v_260 + __v_268);
+                let __v_270: G = (__v_258 + __v_269);
+                let __v_271: G = (__v_256 + __v_270);
+                let __v_272: G = (__v_254 + __v_271);
+                let __v_273: G = (__v_125 + __v_272);
+                let __v_274: G = G::from_u64(256);
+                let __v_275: G = (__v_274 * __v_151);
+                let __v_276: G = G::from_u64(65536);
+                let __v_277: G = (__v_276 * __v_152);
+                let __v_278: G = G::from_u64(16777216);
+                let __v_279: G = (__v_278 * __v_153);
+                let __v_280: G = G::from_u64(4294967296);
+                let __v_281: G = (__v_280 * __v_154);
+                let __v_282: G = G::from_u64(1099511627776);
+                let __v_283: G = (__v_282 * __v_155);
+                let __v_284: G = G::from_u64(281474976710656);
+                let __v_285: G = (__v_284 * __v_156);
+                let __v_286: G = G::from_u64(72057594037927936);
+                let __v_287: G = (__v_286 * __v_157);
+                let __v_288: G = (__v_285 + __v_287);
+                let __v_289: G = (__v_283 + __v_288);
+                let __v_290: G = (__v_281 + __v_289);
+                let __v_291: G = (__v_279 + __v_290);
+                let __v_292: G = (__v_277 + __v_291);
+                let __v_293: G = (__v_275 + __v_292);
+                let __v_294: G = (__v_150 + __v_293);
+                let __v_295: G = G::from_u64(256);
+                let __v_296: G = (__v_295 * __v_159);
+                let __v_297: G = G::from_u64(65536);
+                let __v_298: G = (__v_297 * __v_160);
+                let __v_299: G = G::from_u64(16777216);
+                let __v_300: G = (__v_299 * __v_161);
+                let __v_301: G = G::from_u64(4294967296);
+                let __v_302: G = (__v_301 * __v_162);
+                let __v_303: G = G::from_u64(1099511627776);
+                let __v_304: G = (__v_303 * __v_163);
+                let __v_305: G = G::from_u64(281474976710656);
+                let __v_306: G = (__v_305 * __v_164);
+                let __v_307: G = G::from_u64(72057594037927936);
+                let __v_308: G = (__v_307 * __v_165);
+                let __v_309: G = (__v_306 + __v_308);
+                let __v_310: G = (__v_304 + __v_309);
+                let __v_311: G = (__v_302 + __v_310);
+                let __v_312: G = (__v_300 + __v_311);
+                let __v_313: G = (__v_298 + __v_312);
+                let __v_314: G = (__v_296 + __v_313);
+                let __v_315: G = (__v_158 + __v_314);
+                let __v_316: G = G::from_u64(256);
+                let __v_317: G = (__v_316 * __v_173);
+                let __v_318: G = G::from_u64(65536);
+                let __v_319: G = (__v_318 * __v_174);
+                let __v_320: G = G::from_u64(16777216);
+                let __v_321: G = (__v_320 * __v_175);
+                let __v_322: G = G::from_u64(4294967296);
+                let __v_323: G = (__v_322 * __v_176);
+                let __v_324: G = G::from_u64(1099511627776);
+                let __v_325: G = (__v_324 * __v_177);
+                let __v_326: G = G::from_u64(281474976710656);
+                let __v_327: G = (__v_326 * __v_178);
+                let __v_328: G = G::from_u64(72057594037927936);
+                let __v_329: G = (__v_328 * __v_179);
+                let __v_330: G = (__v_327 + __v_329);
+                let __v_331: G = (__v_325 + __v_330);
+                let __v_332: G = (__v_323 + __v_331);
+                let __v_333: G = (__v_321 + __v_332);
+                let __v_334: G = (__v_319 + __v_333);
+                let __v_335: G = (__v_317 + __v_334);
+                let __v_336: G = (__v_172 + __v_335);
+                let __v_337: G = G::from_u64(256);
+                let __v_338: G = (__v_337 * __v_181);
+                let __v_339: G = G::from_u64(65536);
+                let __v_340: G = (__v_339 * __v_182);
+                let __v_341: G = G::from_u64(16777216);
+                let __v_342: G = (__v_341 * __v_183);
+                let __v_343: G = G::from_u64(4294967296);
+                let __v_344: G = (__v_343 * __v_184);
+                let __v_345: G = G::from_u64(1099511627776);
+                let __v_346: G = (__v_345 * __v_185);
+                let __v_347: G = G::from_u64(281474976710656);
+                let __v_348: G = (__v_347 * __v_186);
+                let __v_349: G = G::from_u64(72057594037927936);
+                let __v_350: G = (__v_349 * __v_187);
+                let __v_351: G = (__v_348 + __v_350);
+                let __v_352: G = (__v_346 + __v_351);
+                let __v_353: G = (__v_344 + __v_352);
+                let __v_354: G = (__v_342 + __v_353);
+                let __v_355: G = (__v_340 + __v_354);
+                let __v_356: G = (__v_338 + __v_355);
+                let __v_357: G = (__v_180 + __v_356);
+                let __v_358: G = G::from_u64(0);
+                let __v_359: G = G::from_u64(0);
+                let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+                let __v_360: G = __r_arr[0];
+                let __v_361: G = __r_arr[1];
+                let __v_362: G = G::from_u64(0);
+                let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_37, __v_38, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_362, __v_360, __v_361, __v_210, __v_231, __v_252, __v_273, __v_294, __v_315, __v_336, __v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+                let __v_363: G = __r_arr[0];
+                let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+                let __v_364: G = __r_arr[0];
+                match __v_0.as_canonical_u64() {
+                  _ => {
                     match __v_18.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
                         let __v_365: G = __r_arr[0];
                         let __v_366: G = G::from_u64(1);
                         let __v_367: G = G::from_u64(1);
@@ -17706,7 +17955,7 @@ fn aiur_fn_183(
     break '__mc_1 [__v_368];
   },
   1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_32, __v_368]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_32, __v_368]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
     let __v_369: G = __r_arr[0];
     break '__mc_1 [__v_369];
   },
@@ -17716,18 +17965,18 @@ fn aiur_fn_183(
 }
  };
                         let __v_369: G = __mc_out___mc_1[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_30, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
                         let __v_370: G = __r_arr[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_34, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_34, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
                         let __v_371: G = __r_arr[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_33, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_33, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
                         let __v_372: G = __r_arr[0];
-                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_188, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_188, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
                         let __v_373: G = __r_arr[0];
                         let __v_374: G = G::from_u64(1);
                         let __v_375: G = G::from_u64(1);
                         let __v_376: G = { let __values: [G; 3] = [__v_374, __v_375, __v_375]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_373, __v_376]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_373, __v_376]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
                         let __v_377: G = __r_arr[0];
                         let __v_378: G = __r_arr[1];
                         let __v_379: G = __r_arr[2];
@@ -17788,31 +18037,31 @@ fn aiur_fn_183(
                         let __v_434: G = (__v_419 + __v_433);
                         let __v_435: G = (__v_417 + __v_434);
                         let __v_436: G = (__v_385 + __v_435);
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_393, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_393, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
                         let __v_437: G = __r_arr[0];
                         let __v_438: G = __r_arr[1];
                         let __v_439: G = G::from_u64(1);
                         let __v_440: G = G::from_u64(1);
                         let __v_441: G = { let __values: [G; 3] = [__v_439, __v_440, __v_440]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_21, __v_441]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_21, __v_441]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
                         let __v_442: G = __r_arr[0];
-                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
                         let __v_443: G = __r_arr[0];
-                        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_443, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_443, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                         let __v_444: G = __r_arr[0];
-                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_444, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_444, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
                         let __v_445: G = __r_arr[0];
                         let __v_446: G = __r_arr[1];
                         let __v_447: G = (__v_365 + __v_0);
-                        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
                         let __v_448: G = __r_arr[0];
                         let __v_449: G = G::from_u64(1);
                         if (__v_448 != __v_449) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_449.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
                         let __v_450: G = __r_arr[0];
-                        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
                         let __v_451: G = __r_arr[0];
                         let __v_452: G = (__v_450 - __v_451);
                         let __v_453: G = G::from_bool((__v_452 == G::ZERO));
@@ -17820,9 +18069,9 @@ fn aiur_fn_183(
                         if (__v_453 != __v_454) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_453.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
                         let __v_455: G = __r_arr[0];
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
                         let __v_456: G = __r_arr[0];
                         let __v_457: G = (__v_455 - __v_456);
                         let __v_458: G = G::from_bool((__v_457 == G::ZERO));
@@ -17830,7 +18079,7 @@ fn aiur_fn_183(
                         if (__v_458 != __v_459) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_458.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                         let __v_460: G = __r_arr[0];
                         let __v_461: G = (__v_460 - __v_365);
                         let __v_462: G = G::from_bool((__v_461 == G::ZERO));
@@ -17838,7 +18087,7 @@ fn aiur_fn_183(
                         if (__v_462 != __v_463) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_462.as_canonical_u64(), rhs: __v_463.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
                         let __v_464: G = __r_arr[0];
                         let __v_465: G = (__v_464 - __v_4);
                         let __v_466: G = G::from_bool((__v_465 == G::ZERO));
@@ -17846,7 +18095,7 @@ fn aiur_fn_183(
                         if (__v_466 != __v_467) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
                         let __v_468: G = __r_arr[0];
                         let __v_469: G = G::from_u64(1);
                         if (__v_468 != __v_469) {
@@ -17858,10 +18107,10 @@ fn aiur_fn_183(
                         if (__v_471 != __v_472) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_471.as_canonical_u64(), rhs: __v_472.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_445, __v_446, __v_20, __v_415, __v_436, __v_33, __v_34, __v_30, __v_31, __v_32, __v_13, __v_14, __v_15, __v_39, __v_38, __v_17, __v_336, __v_357, __v_364, __v_0, __v_447, __v_437, __v_18, __v_21, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_445, __v_446, __v_20, __v_415, __v_436, __v_33, __v_34, __v_30, __v_31, __v_32, __v_13, __v_14, __v_15, __v_39, __v_38, __v_17, __v_336, __v_357, __v_364, __v_0, __v_447, __v_437, __v_18, __v_21, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
                         let __v_473: G = __r_arr[0];
-                        let __ret: [G; OUT_183] = [__v_473];
-                        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_196] = [__v_473];
+                        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -17876,15 +18125,15 @@ fn aiur_fn_183(
   })
 }
 
-const INPUT_SIZE_184: usize = 1;
-const IN_184: usize = 1;
-const OUT_184: usize = 1;
-fn aiur_fn_184(
-  inp: [G; IN_184],
+const INPUT_SIZE_197: usize = 1;
+const IN_197: usize = 1;
+const OUT_197: usize = 1;
+fn aiur_fn_197(
+  inp: [G; IN_197],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], ExecError> {
+) -> Result<[G; OUT_197], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -17894,8 +18143,8 @@ fn aiur_fn_184(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_184] = [__v_4];
-        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_197] = [__v_4];
+        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -17906,10 +18155,10 @@ fn aiur_fn_184(
         if (__v_6 != __v_7) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_184] = [__v_8];
-        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_197] = [__v_8];
+        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -17919,15 +18168,15 @@ fn aiur_fn_184(
   })
 }
 
-const INPUT_SIZE_185: usize = 2;
-const IN_185: usize = 2;
-const OUT_185: usize = 1;
-fn aiur_fn_185(
-  inp: [G; IN_185],
+const INPUT_SIZE_198: usize = 2;
+const IN_198: usize = 2;
+const OUT_198: usize = 1;
+fn aiur_fn_198(
+  inp: [G; IN_198],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_185], ExecError> {
+) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17945,8 +18194,8 @@ fn aiur_fn_185(
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_185] = [__v_12];
-        if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_198] = [__v_12];
+        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -17958,19 +18207,19 @@ fn aiur_fn_185(
           0u64 => {
             match __v_11.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_185] = [__v_13];
-                if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_198] = [__v_13];
+                if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_185] = [__v_15];
-                if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_198] = [__v_15];
+                if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -17987,15 +18236,15 @@ fn aiur_fn_185(
   })
 }
 
-const INPUT_SIZE_186: usize = 2;
-const IN_186: usize = 2;
-const OUT_186: usize = 1;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+const INPUT_SIZE_199: usize = 2;
+const IN_199: usize = 2;
+const OUT_199: usize = 1;
+fn aiur_fn_199(
+  inp: [G; IN_199],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_186], ExecError> {
+) -> Result<[G; OUT_199], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18009,8 +18258,8 @@ fn aiur_fn_186(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_186] = [__v_8];
-        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_199] = [__v_8];
+        if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -18022,19 +18271,19 @@ fn aiur_fn_186(
           0u64 => {
             match __v_7.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_186] = [__v_9];
-                if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_199] = [__v_9];
+                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_186] = [__v_11];
-                if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_199] = [__v_11];
+                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -18051,38 +18300,38 @@ fn aiur_fn_186(
   })
 }
 
-const INPUT_SIZE_187: usize = 1;
-const IN_187: usize = 1;
-const OUT_187: usize = 2;
-fn aiur_fn_187(
-  inp: [G; IN_187],
+const INPUT_SIZE_200: usize = 1;
+const IN_200: usize = 1;
+const OUT_200: usize = 2;
+fn aiur_fn_200(
+  inp: [G; IN_200],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_187], ExecError> {
+) -> Result<[G; OUT_200], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_187] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_200] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_188: usize = 2;
-const IN_188: usize = 2;
-const OUT_188: usize = 2;
-fn aiur_fn_188(
-  inp: [G; IN_188],
+const INPUT_SIZE_201: usize = 2;
+const IN_201: usize = 2;
+const OUT_201: usize = 2;
+fn aiur_fn_201(
+  inp: [G; IN_201],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_188], ExecError> {
+) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18091,64 +18340,64 @@ fn aiur_fn_188(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_188] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_201] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 - __v_6);
-        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_188] = [__v_11, __v_9];
-        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_201] = [__v_11, __v_9];
+        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_189: usize = 1;
-const IN_189: usize = 1;
-const OUT_189: usize = 2;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+const OUT_202: usize = 2;
+fn aiur_fn_202(
+  inp: [G; IN_202],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_189], ExecError> {
+) -> Result<[G; OUT_202], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_189] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_202] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_190: usize = 2;
-const IN_190: usize = 2;
-const OUT_190: usize = 2;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+const INPUT_SIZE_203: usize = 2;
+const IN_203: usize = 2;
+const OUT_203: usize = 2;
+fn aiur_fn_203(
+  inp: [G; IN_203],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_190], ExecError> {
+) -> Result<[G; OUT_203], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18157,12 +18406,12 @@ fn aiur_fn_190(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_190] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_203] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -18174,28 +18423,28 @@ fn aiur_fn_190(
         let __v_10: G = __r_arr[8];
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_1 - __v_11);
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
         let __v_15: G = G::from_u64(0);
         let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_190] = [__v_16, __v_14];
-        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_203] = [__v_16, __v_14];
+        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_191: usize = 16;
-const IN_191: usize = 16;
-const OUT_191: usize = 0;
-fn aiur_fn_191(
-  inp: [G; IN_191],
+const INPUT_SIZE_204: usize = 16;
+const IN_204: usize = 16;
+const OUT_204: usize = 0;
+fn aiur_fn_204(
+  inp: [G; IN_204],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_191], ExecError> {
+) -> Result<[G; OUT_204], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18218,49 +18467,49 @@ fn aiur_fn_191(
     let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
     let __v_18: G = __io_pair.0;
     let __v_19: G = __io_pair.1;
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_21, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_21, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
     let __v_22: G = __r_arr[0];
     let __v_23: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
     let __v_24: G = __r_arr[0];
     let __v_25: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
     let __v_26: G = __r_arr[0];
     let __v_27: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
     let __v_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
     let __v_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
     let __v_32: G = __r_arr[0];
     let __v_33: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
     let __v_35: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
     let __v_36: G = __r_arr[0];
     let __v_37: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_37, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
     let __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } };
     let __v_40: G = __r_arr[0];
     let __v_41: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
     let __v_42: G = __r_arr[0];
     let __v_43: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_43, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_43, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
     let __v_44: G = __r_arr[0];
     let __v_45: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
     let __v_46: G = __r_arr[0];
     let __v_47: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_47]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_47]; let __cu = true; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
     let __v_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
     let __v_50: G = __r_arr[2];
@@ -18270,17 +18519,17 @@ fn aiur_fn_191(
     let __v_54: G = __r_arr[6];
     let __v_55: G = __r_arr[7];
     let __v_56: G = __r_arr[8];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
     let __v_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
-    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
     let __v_59: G = __r_arr[0];
     let __v_60: G = __r_arr[1];
     let __v_61: G = __r_arr[2];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
     let __v_62: G = __r_arr[0];
     let __v_63: G = __r_arr[1];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
     let __v_64: G = __r_arr[0];
     let __v_65: G = __r_arr[1];
     let __v_66: G = G::from_u64(1);
@@ -18341,9 +18590,9 @@ fn aiur_fn_191(
     let __v_119: G = G::from_u64(1);
     let __v_120: G = G::from_u64(1);
     let __v_121: G = { let __values: [G; 34] = [__v_119, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_122: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_123: G = __r_arr[0];
     let __v_124: G = __r_arr[1];
     let __v_125: G = __r_arr[2];
@@ -18376,7 +18625,7 @@ fn aiur_fn_191(
     let __v_152: G = __r_arr[29];
     let __v_153: G = __r_arr[30];
     let __v_154: G = __r_arr[31];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_155: G = __r_arr[0];
     let __v_156: G = __r_arr[1];
     let __v_157: G = __r_arr[2];
@@ -18387,7 +18636,7 @@ fn aiur_fn_191(
     let __v_162: G = __r_arr[7];
     let __v_163: G = __r_arr[8];
     let __v_164: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_164]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_164]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_165: G = __r_arr[0];
     let __v_166: G = __r_arr[1];
     let __v_167: G = __r_arr[2];
@@ -18398,7 +18647,7 @@ fn aiur_fn_191(
     let __v_172: G = __r_arr[7];
     let __v_173: G = __r_arr[8];
     let __v_174: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_175: G = __r_arr[0];
     let __v_176: G = __r_arr[1];
     let __v_177: G = __r_arr[2];
@@ -18409,7 +18658,7 @@ fn aiur_fn_191(
     let __v_182: G = __r_arr[7];
     let __v_183: G = __r_arr[8];
     let __v_184: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_184]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_184]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_185: G = __r_arr[0];
     let __v_186: G = __r_arr[1];
     let __v_187: G = __r_arr[2];
@@ -18420,7 +18669,7 @@ fn aiur_fn_191(
     let __v_192: G = __r_arr[7];
     let __v_193: G = __r_arr[8];
     let __v_194: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_194]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_194]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_195: G = __r_arr[0];
     let __v_196: G = __r_arr[1];
     let __v_197: G = __r_arr[2];
@@ -18431,7 +18680,7 @@ fn aiur_fn_191(
     let __v_202: G = __r_arr[7];
     let __v_203: G = __r_arr[8];
     let __v_204: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_205: G = __r_arr[0];
     let __v_206: G = __r_arr[1];
     let __v_207: G = __r_arr[2];
@@ -18442,7 +18691,7 @@ fn aiur_fn_191(
     let __v_212: G = __r_arr[7];
     let __v_213: G = __r_arr[8];
     let __v_214: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_214]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_214]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_215: G = __r_arr[0];
     let __v_216: G = __r_arr[1];
     let __v_217: G = __r_arr[2];
@@ -18470,7 +18719,7 @@ fn aiur_fn_191(
     let __v_239: G = { let __values: [G; 10] = [__v_227, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_240: G = { let __values: [G; 10] = [__v_226, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_241: G = { let __values: [G; 10] = [__v_225, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_224]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_224]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
     let __v_242: G = __r_arr[0];
     let __v_243: G = __r_arr[1];
     let __v_244: G = __r_arr[2];
@@ -18481,20 +18730,20 @@ fn aiur_fn_191(
     let __v_249: G = __r_arr[7];
     let __v_250: G = __r_arr[8];
     let __v_251: G = __r_arr[9];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_251, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_251, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_252: G = __r_arr[0];
     let __v_253: G = __r_arr[1];
     let __v_254: G = __r_arr[2];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_254]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_254]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
     let __v_255: G = __r_arr[0];
     let __v_256: G = __r_arr[1];
     let __v_257: G = __r_arr[2];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_257, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_257, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
     let __v_258: G = __r_arr[0];
     let __v_259: G = __r_arr[1];
     let __v_260: G = G::from_u64(0);
     let __v_261: G = { let __values: [G; 10] = [__v_260, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_253]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_241, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_241, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
     let __v_262: G = __r_arr[0];
     let __v_263: G = G::from_u64(2);
     let __v_264: G = G::from_u64(0);
@@ -18554,9 +18803,9 @@ fn aiur_fn_191(
     let __v_316: G = G::from_u64(1);
     let __v_317: G = G::from_u64(1);
     let __v_318: G = { let __values: [G; 34] = [__v_316, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_268, __v_303, __v_304, __v_305, __v_314, __v_315, __v_318]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_268, __v_303, __v_304, __v_305, __v_314, __v_315, __v_318]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
     let __v_319: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_319]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_319]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_320: G = __r_arr[0];
     let __v_321: G = __r_arr[1];
     let __v_322: G = __r_arr[2];
@@ -18589,37 +18838,37 @@ fn aiur_fn_191(
     let __v_349: G = __r_arr[29];
     let __v_350: G = __r_arr[30];
     let __v_351: G = __r_arr[31];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
     let __v_352: G = __r_arr[0];
     let __v_353: G = __r_arr[1];
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_353, __v_352]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_353, __v_352]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_354: G = __r_arr[0];
     let __v_355: G = __r_arr[1];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() {
   _ => {
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
     let __v_356: G = __r_arr[0];
     let __v_357: G = G::from_bool((__v_356 == G::ZERO));
     let __v_358: G = G::from_u64(0);
     if (__v_357 != __v_358) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_358.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
     let __v_359: G = __r_arr[0];
     if (__v_359 != __v_356) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
     let __v_360: G = __r_arr[0];
     if (__v_360 != __v_356) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
     let __v_361: G = __r_arr[0];
     if (__v_361 != __v_356) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
     let __v_362: G = __r_arr[0];
     let __v_363: G = G::from_u64(1);
     if (__v_362 != __v_363) {
@@ -18633,17 +18882,15 @@ fn aiur_fn_191(
     let __v_356: G = __mc_out___mc_0[0];
     let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_155.as_canonical_u64() {
   _ => {
-    match __v_155.as_canonical_u64() {
+    match __v_22.as_canonical_u64() {
       _ => {
-        match __v_22.as_canonical_u64() {
+        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_252, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __v_357: G = __r_arr[0];
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_258, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __v_358: G = __r_arr[0];
+        match __v_24.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_252, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
-            let __v_357: G = __r_arr[0];
-            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_258, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
-            let __v_358: G = __r_arr[0];
-            match __v_24.as_canonical_u64() {
-              _ => {
-                let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_255.as_canonical_u64() {
+            let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_255.as_canonical_u64() {
   0u64 => {
     let __v_359: G = G::from_u64(1);
     let __v_360: G = G::from_u64(1);
@@ -18658,357 +18905,359 @@ fn aiur_fn_191(
   },
 }
  };
-                let __v_359: G = __mc_out___mc_2[0];
-                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_34, __v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                let __v_360: G = __r_arr[0];
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_24, __v_360]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                let __v_361: G = __r_arr[0];
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_359, __v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                let __v_362: G = __r_arr[0];
-                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_22, __v_362]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                let __v_363: G = __r_arr[0];
-                let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_262, __v_363]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
-                let __v_364: G = __r_arr[0];
-                let __v_365: G = G::from_u64(0);
-                let __v_366: G = G::from_u64(109);
-                let __v_367: G = G::from_u64(0);
-                let __v_368: G = G::from_u64(117);
-                let __v_369: G = G::from_u64(0);
-                let __v_370: G = G::from_u64(108);
-                let __v_371: G = G::from_u64(0);
-                let __v_372: G = G::from_u64(116);
-                let __v_373: G = G::from_u64(0);
-                let __v_374: G = G::from_u64(105);
-                let __v_375: G = G::from_u64(0);
-                let __v_376: G = G::from_u64(45);
-                let __v_377: G = G::from_u64(0);
-                let __v_378: G = G::from_u64(115);
-                let __v_379: G = G::from_u64(0);
-                let __v_380: G = G::from_u64(116);
-                let __v_381: G = G::from_u64(0);
-                let __v_382: G = G::from_u64(97);
-                let __v_383: G = G::from_u64(0);
-                let __v_384: G = G::from_u64(114);
-                let __v_385: G = G::from_u64(0);
-                let __v_386: G = G::from_u64(107);
-                let __v_387: G = G::from_u64(0);
-                let __v_388: G = G::from_u64(47);
-                let __v_389: G = G::from_u64(0);
-                let __v_390: G = G::from_u64(118);
-                let __v_391: G = G::from_u64(0);
-                let __v_392: G = G::from_u64(48);
-                let __v_393: G = { let __values: [G; 3] = [__v_391, __v_392, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_394: G = { let __values: [G; 3] = [__v_389, __v_390, __v_393]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_395: G = { let __values: [G; 3] = [__v_387, __v_388, __v_394]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_396: G = { let __values: [G; 3] = [__v_385, __v_386, __v_395]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_397: G = { let __values: [G; 3] = [__v_383, __v_384, __v_396]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_398: G = { let __values: [G; 3] = [__v_381, __v_382, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_399: G = { let __values: [G; 3] = [__v_379, __v_380, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_400: G = { let __values: [G; 3] = [__v_377, __v_378, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_401: G = { let __values: [G; 3] = [__v_375, __v_376, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_402: G = { let __values: [G; 3] = [__v_373, __v_374, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_403: G = { let __values: [G; 3] = [__v_371, __v_372, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_404: G = { let __values: [G; 3] = [__v_369, __v_370, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_405: G = { let __values: [G; 3] = [__v_367, __v_368, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_406: G = { let __values: [G; 3] = [__v_365, __v_366, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_407: G = G::from_u64(1);
-                let __v_408: G = G::from_u64(1);
-                let __v_409: G = { let __values: [G; 3] = [__v_407, __v_408, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_406, __v_409]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_410: G = __r_arr[0];
-                let __v_411: G = __r_arr[1];
-                let __v_412: G = __r_arr[2];
-                let __v_413: G = __r_arr[3];
-                let __v_414: G = __r_arr[4];
-                let __v_415: G = __r_arr[5];
-                let __v_416: G = __r_arr[6];
-                let __v_417: G = __r_arr[7];
-                let __v_418: G = __r_arr[8];
-                let __v_419: G = __r_arr[9];
-                let __v_420: G = __r_arr[10];
-                let __v_421: G = __r_arr[11];
-                let __v_422: G = __r_arr[12];
-                let __v_423: G = __r_arr[13];
-                let __v_424: G = __r_arr[14];
-                let __v_425: G = __r_arr[15];
-                let __v_426: G = __r_arr[16];
-                let __v_427: G = __r_arr[17];
-                let __v_428: G = G::from_u64(1);
-                let __v_429: G = G::from_u64(1);
-                let __v_430: G = { let __values: [G; 3] = [__v_428, __v_429, __v_429]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_430]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_431: G = __r_arr[0];
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_431]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_432: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_426, __v_432]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_433: G = __r_arr[0];
-                let __v_434: G = G::from_u64(1);
-                let __v_435: G = G::from_u64(1);
-                let __v_436: G = { let __values: [G; 3] = [__v_434, __v_435, __v_435]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_433, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_437: G = __r_arr[0];
-                let __v_438: G = __r_arr[1];
-                let __v_439: G = __r_arr[2];
-                let __v_440: G = __r_arr[3];
-                let __v_441: G = __r_arr[4];
-                let __v_442: G = __r_arr[5];
-                let __v_443: G = __r_arr[6];
-                let __v_444: G = __r_arr[7];
-                let __v_445: G = __r_arr[8];
-                let __v_446: G = __r_arr[9];
-                let __v_447: G = __r_arr[10];
-                let __v_448: G = __r_arr[11];
-                let __v_449: G = __r_arr[12];
-                let __v_450: G = __r_arr[13];
-                let __v_451: G = __r_arr[14];
-                let __v_452: G = __r_arr[15];
-                let __v_453: G = __r_arr[16];
-                let __v_454: G = __r_arr[17];
-                let __v_455: G = G::from_u64(1);
-                let __v_456: G = G::from_u64(1);
-                let __v_457: G = { let __values: [G; 3] = [__v_455, __v_456, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_445, __v_446, __v_447, __v_448, __v_449, __v_450, __v_451, __v_452, __v_457]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_458: G = __r_arr[0];
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_458]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_459: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_453, __v_459]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_460: G = __r_arr[0];
-                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_460, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                let __v_461: G = __r_arr[0];
-                let __v_462: G = G::from_u64(1);
-                let __v_463: G = G::from_u64(1);
-                let __v_464: G = { let __values: [G; 3] = [__v_462, __v_463, __v_463]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_30, __v_464]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-                let __v_465: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_461, __v_465]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_466: G = __r_arr[0];
-                let __v_467: G = G::from_u64(1);
-                let __v_468: G = G::from_u64(1);
-                let __v_469: G = { let __values: [G; 3] = [__v_467, __v_468, __v_468]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_466, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_470: G = __r_arr[0];
-                let __v_471: G = __r_arr[1];
-                let __v_472: G = __r_arr[2];
-                let __v_473: G = __r_arr[3];
-                let __v_474: G = __r_arr[4];
-                let __v_475: G = __r_arr[5];
-                let __v_476: G = __r_arr[6];
-                let __v_477: G = __r_arr[7];
-                let __v_478: G = __r_arr[8];
-                let __v_479: G = __r_arr[9];
-                let __v_480: G = __r_arr[10];
-                let __v_481: G = __r_arr[11];
-                let __v_482: G = __r_arr[12];
-                let __v_483: G = __r_arr[13];
-                let __v_484: G = __r_arr[14];
-                let __v_485: G = __r_arr[15];
-                let __v_486: G = __r_arr[16];
-                let __v_487: G = __r_arr[17];
-                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_486, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                let __v_488: G = __r_arr[0];
-                let __v_489: G = G::from_u64(1);
-                let __v_490: G = G::from_u64(1);
-                let __v_491: G = { let __values: [G; 3] = [__v_489, __v_490, __v_490]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_488, __v_491]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_492: G = __r_arr[0];
-                let __v_493: G = __r_arr[1];
-                let __v_494: G = __r_arr[2];
-                let __v_495: G = __r_arr[3];
-                let __v_496: G = __r_arr[4];
-                let __v_497: G = __r_arr[5];
-                let __v_498: G = __r_arr[6];
-                let __v_499: G = __r_arr[7];
-                let __v_500: G = __r_arr[8];
-                let __v_501: G = __r_arr[9];
-                let __v_502: G = __r_arr[10];
-                let __v_503: G = __r_arr[11];
-                let __v_504: G = __r_arr[12];
-                let __v_505: G = __r_arr[13];
-                let __v_506: G = __r_arr[14];
-                let __v_507: G = __r_arr[15];
-                let __v_508: G = __r_arr[16];
-                let __v_509: G = __r_arr[17];
-                let __v_510: G = G::from_u64(256);
-                let __v_511: G = (__v_510 * __v_411);
-                let __v_512: G = G::from_u64(65536);
-                let __v_513: G = (__v_512 * __v_412);
-                let __v_514: G = G::from_u64(16777216);
-                let __v_515: G = (__v_514 * __v_413);
-                let __v_516: G = G::from_u64(4294967296);
-                let __v_517: G = (__v_516 * __v_414);
-                let __v_518: G = G::from_u64(1099511627776);
-                let __v_519: G = (__v_518 * __v_415);
-                let __v_520: G = G::from_u64(281474976710656);
-                let __v_521: G = (__v_520 * __v_416);
-                let __v_522: G = G::from_u64(72057594037927936);
-                let __v_523: G = (__v_522 * __v_417);
-                let __v_524: G = (__v_521 + __v_523);
-                let __v_525: G = (__v_519 + __v_524);
-                let __v_526: G = (__v_517 + __v_525);
-                let __v_527: G = (__v_515 + __v_526);
-                let __v_528: G = (__v_513 + __v_527);
-                let __v_529: G = (__v_511 + __v_528);
-                let __v_530: G = (__v_410 + __v_529);
-                let __v_531: G = G::from_u64(256);
-                let __v_532: G = (__v_531 * __v_419);
-                let __v_533: G = G::from_u64(65536);
-                let __v_534: G = (__v_533 * __v_420);
-                let __v_535: G = G::from_u64(16777216);
-                let __v_536: G = (__v_535 * __v_421);
-                let __v_537: G = G::from_u64(4294967296);
-                let __v_538: G = (__v_537 * __v_422);
-                let __v_539: G = G::from_u64(1099511627776);
-                let __v_540: G = (__v_539 * __v_423);
-                let __v_541: G = G::from_u64(281474976710656);
-                let __v_542: G = (__v_541 * __v_424);
-                let __v_543: G = G::from_u64(72057594037927936);
-                let __v_544: G = (__v_543 * __v_425);
-                let __v_545: G = (__v_542 + __v_544);
-                let __v_546: G = (__v_540 + __v_545);
-                let __v_547: G = (__v_538 + __v_546);
-                let __v_548: G = (__v_536 + __v_547);
-                let __v_549: G = (__v_534 + __v_548);
-                let __v_550: G = (__v_532 + __v_549);
-                let __v_551: G = (__v_418 + __v_550);
-                let __v_552: G = G::from_u64(256);
-                let __v_553: G = (__v_552 * __v_438);
-                let __v_554: G = G::from_u64(65536);
-                let __v_555: G = (__v_554 * __v_439);
-                let __v_556: G = G::from_u64(16777216);
-                let __v_557: G = (__v_556 * __v_440);
-                let __v_558: G = G::from_u64(4294967296);
-                let __v_559: G = (__v_558 * __v_441);
-                let __v_560: G = G::from_u64(1099511627776);
-                let __v_561: G = (__v_560 * __v_442);
-                let __v_562: G = G::from_u64(281474976710656);
-                let __v_563: G = (__v_562 * __v_443);
-                let __v_564: G = G::from_u64(72057594037927936);
-                let __v_565: G = (__v_564 * __v_444);
-                let __v_566: G = (__v_563 + __v_565);
-                let __v_567: G = (__v_561 + __v_566);
-                let __v_568: G = (__v_559 + __v_567);
-                let __v_569: G = (__v_557 + __v_568);
-                let __v_570: G = (__v_555 + __v_569);
-                let __v_571: G = (__v_553 + __v_570);
-                let __v_572: G = (__v_437 + __v_571);
-                let __v_573: G = G::from_u64(256);
-                let __v_574: G = (__v_573 * __v_446);
-                let __v_575: G = G::from_u64(65536);
-                let __v_576: G = (__v_575 * __v_447);
-                let __v_577: G = G::from_u64(16777216);
-                let __v_578: G = (__v_577 * __v_448);
-                let __v_579: G = G::from_u64(4294967296);
-                let __v_580: G = (__v_579 * __v_449);
-                let __v_581: G = G::from_u64(1099511627776);
-                let __v_582: G = (__v_581 * __v_450);
-                let __v_583: G = G::from_u64(281474976710656);
-                let __v_584: G = (__v_583 * __v_451);
-                let __v_585: G = G::from_u64(72057594037927936);
-                let __v_586: G = (__v_585 * __v_452);
-                let __v_587: G = (__v_584 + __v_586);
-                let __v_588: G = (__v_582 + __v_587);
-                let __v_589: G = (__v_580 + __v_588);
-                let __v_590: G = (__v_578 + __v_589);
-                let __v_591: G = (__v_576 + __v_590);
-                let __v_592: G = (__v_574 + __v_591);
-                let __v_593: G = (__v_445 + __v_592);
-                let __v_594: G = G::from_u64(256);
-                let __v_595: G = (__v_594 * __v_471);
-                let __v_596: G = G::from_u64(65536);
-                let __v_597: G = (__v_596 * __v_472);
-                let __v_598: G = G::from_u64(16777216);
-                let __v_599: G = (__v_598 * __v_473);
-                let __v_600: G = G::from_u64(4294967296);
-                let __v_601: G = (__v_600 * __v_474);
-                let __v_602: G = G::from_u64(1099511627776);
-                let __v_603: G = (__v_602 * __v_475);
-                let __v_604: G = G::from_u64(281474976710656);
-                let __v_605: G = (__v_604 * __v_476);
-                let __v_606: G = G::from_u64(72057594037927936);
-                let __v_607: G = (__v_606 * __v_477);
-                let __v_608: G = (__v_605 + __v_607);
-                let __v_609: G = (__v_603 + __v_608);
-                let __v_610: G = (__v_601 + __v_609);
-                let __v_611: G = (__v_599 + __v_610);
-                let __v_612: G = (__v_597 + __v_611);
-                let __v_613: G = (__v_595 + __v_612);
-                let __v_614: G = (__v_470 + __v_613);
-                let __v_615: G = G::from_u64(256);
-                let __v_616: G = (__v_615 * __v_479);
-                let __v_617: G = G::from_u64(65536);
-                let __v_618: G = (__v_617 * __v_480);
-                let __v_619: G = G::from_u64(16777216);
-                let __v_620: G = (__v_619 * __v_481);
-                let __v_621: G = G::from_u64(4294967296);
-                let __v_622: G = (__v_621 * __v_482);
-                let __v_623: G = G::from_u64(1099511627776);
-                let __v_624: G = (__v_623 * __v_483);
-                let __v_625: G = G::from_u64(281474976710656);
-                let __v_626: G = (__v_625 * __v_484);
-                let __v_627: G = G::from_u64(72057594037927936);
-                let __v_628: G = (__v_627 * __v_485);
-                let __v_629: G = (__v_626 + __v_628);
-                let __v_630: G = (__v_624 + __v_629);
-                let __v_631: G = (__v_622 + __v_630);
-                let __v_632: G = (__v_620 + __v_631);
-                let __v_633: G = (__v_618 + __v_632);
-                let __v_634: G = (__v_616 + __v_633);
-                let __v_635: G = (__v_478 + __v_634);
-                let __v_636: G = G::from_u64(256);
-                let __v_637: G = (__v_636 * __v_493);
-                let __v_638: G = G::from_u64(65536);
-                let __v_639: G = (__v_638 * __v_494);
-                let __v_640: G = G::from_u64(16777216);
-                let __v_641: G = (__v_640 * __v_495);
-                let __v_642: G = G::from_u64(4294967296);
-                let __v_643: G = (__v_642 * __v_496);
-                let __v_644: G = G::from_u64(1099511627776);
-                let __v_645: G = (__v_644 * __v_497);
-                let __v_646: G = G::from_u64(281474976710656);
-                let __v_647: G = (__v_646 * __v_498);
-                let __v_648: G = G::from_u64(72057594037927936);
-                let __v_649: G = (__v_648 * __v_499);
-                let __v_650: G = (__v_647 + __v_649);
-                let __v_651: G = (__v_645 + __v_650);
-                let __v_652: G = (__v_643 + __v_651);
-                let __v_653: G = (__v_641 + __v_652);
-                let __v_654: G = (__v_639 + __v_653);
-                let __v_655: G = (__v_637 + __v_654);
-                let __v_656: G = (__v_492 + __v_655);
-                let __v_657: G = G::from_u64(256);
-                let __v_658: G = (__v_657 * __v_501);
-                let __v_659: G = G::from_u64(65536);
-                let __v_660: G = (__v_659 * __v_502);
-                let __v_661: G = G::from_u64(16777216);
-                let __v_662: G = (__v_661 * __v_503);
-                let __v_663: G = G::from_u64(4294967296);
-                let __v_664: G = (__v_663 * __v_504);
-                let __v_665: G = G::from_u64(1099511627776);
-                let __v_666: G = (__v_665 * __v_505);
-                let __v_667: G = G::from_u64(281474976710656);
-                let __v_668: G = (__v_667 * __v_506);
-                let __v_669: G = G::from_u64(72057594037927936);
-                let __v_670: G = (__v_669 * __v_507);
-                let __v_671: G = (__v_668 + __v_670);
-                let __v_672: G = (__v_666 + __v_671);
-                let __v_673: G = (__v_664 + __v_672);
-                let __v_674: G = (__v_662 + __v_673);
-                let __v_675: G = (__v_660 + __v_674);
-                let __v_676: G = (__v_658 + __v_675);
-                let __v_677: G = (__v_500 + __v_676);
-                let __v_678: G = G::from_u64(0);
-                let __v_679: G = G::from_u64(0);
-                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_678, __v_679, __v_354, __v_530, __v_551, __v_572, __v_593]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
-                let __v_680: G = __r_arr[0];
-                let __v_681: G = __r_arr[1];
-                let __v_682: G = G::from_u64(0);
-                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_357, __v_358, __v_34, __v_30, __v_62, __v_64, __v_59, __v_60, __v_57, __v_682, __v_680, __v_681, __v_530, __v_551, __v_572, __v_593, __v_614, __v_635, __v_656, __v_677]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-                let __v_683: G = __r_arr[0];
-                let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                let __v_684: G = __r_arr[0];
+            let __v_359: G = __mc_out___mc_2[0];
+            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_34, __v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+            let __v_360: G = __r_arr[0];
+            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_24, __v_360]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+            let __v_361: G = __r_arr[0];
+            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_359, __v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+            let __v_362: G = __r_arr[0];
+            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_22, __v_362]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+            let __v_363: G = __r_arr[0];
+            let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_262, __v_363]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
+            let __v_364: G = __r_arr[0];
+            let __v_365: G = G::from_u64(0);
+            let __v_366: G = G::from_u64(109);
+            let __v_367: G = G::from_u64(0);
+            let __v_368: G = G::from_u64(117);
+            let __v_369: G = G::from_u64(0);
+            let __v_370: G = G::from_u64(108);
+            let __v_371: G = G::from_u64(0);
+            let __v_372: G = G::from_u64(116);
+            let __v_373: G = G::from_u64(0);
+            let __v_374: G = G::from_u64(105);
+            let __v_375: G = G::from_u64(0);
+            let __v_376: G = G::from_u64(45);
+            let __v_377: G = G::from_u64(0);
+            let __v_378: G = G::from_u64(115);
+            let __v_379: G = G::from_u64(0);
+            let __v_380: G = G::from_u64(116);
+            let __v_381: G = G::from_u64(0);
+            let __v_382: G = G::from_u64(97);
+            let __v_383: G = G::from_u64(0);
+            let __v_384: G = G::from_u64(114);
+            let __v_385: G = G::from_u64(0);
+            let __v_386: G = G::from_u64(107);
+            let __v_387: G = G::from_u64(0);
+            let __v_388: G = G::from_u64(47);
+            let __v_389: G = G::from_u64(0);
+            let __v_390: G = G::from_u64(118);
+            let __v_391: G = G::from_u64(0);
+            let __v_392: G = G::from_u64(48);
+            let __v_393: G = { let __values: [G; 3] = [__v_391, __v_392, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_394: G = { let __values: [G; 3] = [__v_389, __v_390, __v_393]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_395: G = { let __values: [G; 3] = [__v_387, __v_388, __v_394]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_396: G = { let __values: [G; 3] = [__v_385, __v_386, __v_395]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_397: G = { let __values: [G; 3] = [__v_383, __v_384, __v_396]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_398: G = { let __values: [G; 3] = [__v_381, __v_382, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_399: G = { let __values: [G; 3] = [__v_379, __v_380, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_400: G = { let __values: [G; 3] = [__v_377, __v_378, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_401: G = { let __values: [G; 3] = [__v_375, __v_376, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_402: G = { let __values: [G; 3] = [__v_373, __v_374, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_403: G = { let __values: [G; 3] = [__v_371, __v_372, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_404: G = { let __values: [G; 3] = [__v_369, __v_370, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_405: G = { let __values: [G; 3] = [__v_367, __v_368, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_406: G = { let __values: [G; 3] = [__v_365, __v_366, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_407: G = G::from_u64(1);
+            let __v_408: G = G::from_u64(1);
+            let __v_409: G = { let __values: [G; 3] = [__v_407, __v_408, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_406, __v_409]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+            let __v_410: G = __r_arr[0];
+            let __v_411: G = __r_arr[1];
+            let __v_412: G = __r_arr[2];
+            let __v_413: G = __r_arr[3];
+            let __v_414: G = __r_arr[4];
+            let __v_415: G = __r_arr[5];
+            let __v_416: G = __r_arr[6];
+            let __v_417: G = __r_arr[7];
+            let __v_418: G = __r_arr[8];
+            let __v_419: G = __r_arr[9];
+            let __v_420: G = __r_arr[10];
+            let __v_421: G = __r_arr[11];
+            let __v_422: G = __r_arr[12];
+            let __v_423: G = __r_arr[13];
+            let __v_424: G = __r_arr[14];
+            let __v_425: G = __r_arr[15];
+            let __v_426: G = __r_arr[16];
+            let __v_427: G = __r_arr[17];
+            let __v_428: G = G::from_u64(1);
+            let __v_429: G = G::from_u64(1);
+            let __v_430: G = { let __values: [G; 3] = [__v_428, __v_429, __v_429]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_430]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+            let __v_431: G = __r_arr[0];
+            let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_431]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+            let __v_432: G = __r_arr[0];
+            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_426, __v_432]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+            let __v_433: G = __r_arr[0];
+            let __v_434: G = G::from_u64(1);
+            let __v_435: G = G::from_u64(1);
+            let __v_436: G = { let __values: [G; 3] = [__v_434, __v_435, __v_435]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_433, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+            let __v_437: G = __r_arr[0];
+            let __v_438: G = __r_arr[1];
+            let __v_439: G = __r_arr[2];
+            let __v_440: G = __r_arr[3];
+            let __v_441: G = __r_arr[4];
+            let __v_442: G = __r_arr[5];
+            let __v_443: G = __r_arr[6];
+            let __v_444: G = __r_arr[7];
+            let __v_445: G = __r_arr[8];
+            let __v_446: G = __r_arr[9];
+            let __v_447: G = __r_arr[10];
+            let __v_448: G = __r_arr[11];
+            let __v_449: G = __r_arr[12];
+            let __v_450: G = __r_arr[13];
+            let __v_451: G = __r_arr[14];
+            let __v_452: G = __r_arr[15];
+            let __v_453: G = __r_arr[16];
+            let __v_454: G = __r_arr[17];
+            let __v_455: G = G::from_u64(1);
+            let __v_456: G = G::from_u64(1);
+            let __v_457: G = { let __values: [G; 3] = [__v_455, __v_456, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_445, __v_446, __v_447, __v_448, __v_449, __v_450, __v_451, __v_452, __v_457]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+            let __v_458: G = __r_arr[0];
+            let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_458]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+            let __v_459: G = __r_arr[0];
+            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_453, __v_459]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+            let __v_460: G = __r_arr[0];
+            let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_460, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+            let __v_461: G = __r_arr[0];
+            let __v_462: G = G::from_u64(1);
+            let __v_463: G = G::from_u64(1);
+            let __v_464: G = { let __values: [G; 3] = [__v_462, __v_463, __v_463]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_30, __v_464]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+            let __v_465: G = __r_arr[0];
+            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_461, __v_465]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+            let __v_466: G = __r_arr[0];
+            let __v_467: G = G::from_u64(1);
+            let __v_468: G = G::from_u64(1);
+            let __v_469: G = { let __values: [G; 3] = [__v_467, __v_468, __v_468]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_466, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+            let __v_470: G = __r_arr[0];
+            let __v_471: G = __r_arr[1];
+            let __v_472: G = __r_arr[2];
+            let __v_473: G = __r_arr[3];
+            let __v_474: G = __r_arr[4];
+            let __v_475: G = __r_arr[5];
+            let __v_476: G = __r_arr[6];
+            let __v_477: G = __r_arr[7];
+            let __v_478: G = __r_arr[8];
+            let __v_479: G = __r_arr[9];
+            let __v_480: G = __r_arr[10];
+            let __v_481: G = __r_arr[11];
+            let __v_482: G = __r_arr[12];
+            let __v_483: G = __r_arr[13];
+            let __v_484: G = __r_arr[14];
+            let __v_485: G = __r_arr[15];
+            let __v_486: G = __r_arr[16];
+            let __v_487: G = __r_arr[17];
+            let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_486, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+            let __v_488: G = __r_arr[0];
+            let __v_489: G = G::from_u64(1);
+            let __v_490: G = G::from_u64(1);
+            let __v_491: G = { let __values: [G; 3] = [__v_489, __v_490, __v_490]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_488, __v_491]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+            let __v_492: G = __r_arr[0];
+            let __v_493: G = __r_arr[1];
+            let __v_494: G = __r_arr[2];
+            let __v_495: G = __r_arr[3];
+            let __v_496: G = __r_arr[4];
+            let __v_497: G = __r_arr[5];
+            let __v_498: G = __r_arr[6];
+            let __v_499: G = __r_arr[7];
+            let __v_500: G = __r_arr[8];
+            let __v_501: G = __r_arr[9];
+            let __v_502: G = __r_arr[10];
+            let __v_503: G = __r_arr[11];
+            let __v_504: G = __r_arr[12];
+            let __v_505: G = __r_arr[13];
+            let __v_506: G = __r_arr[14];
+            let __v_507: G = __r_arr[15];
+            let __v_508: G = __r_arr[16];
+            let __v_509: G = __r_arr[17];
+            let __v_510: G = G::from_u64(256);
+            let __v_511: G = (__v_510 * __v_411);
+            let __v_512: G = G::from_u64(65536);
+            let __v_513: G = (__v_512 * __v_412);
+            let __v_514: G = G::from_u64(16777216);
+            let __v_515: G = (__v_514 * __v_413);
+            let __v_516: G = G::from_u64(4294967296);
+            let __v_517: G = (__v_516 * __v_414);
+            let __v_518: G = G::from_u64(1099511627776);
+            let __v_519: G = (__v_518 * __v_415);
+            let __v_520: G = G::from_u64(281474976710656);
+            let __v_521: G = (__v_520 * __v_416);
+            let __v_522: G = G::from_u64(72057594037927936);
+            let __v_523: G = (__v_522 * __v_417);
+            let __v_524: G = (__v_521 + __v_523);
+            let __v_525: G = (__v_519 + __v_524);
+            let __v_526: G = (__v_517 + __v_525);
+            let __v_527: G = (__v_515 + __v_526);
+            let __v_528: G = (__v_513 + __v_527);
+            let __v_529: G = (__v_511 + __v_528);
+            let __v_530: G = (__v_410 + __v_529);
+            let __v_531: G = G::from_u64(256);
+            let __v_532: G = (__v_531 * __v_419);
+            let __v_533: G = G::from_u64(65536);
+            let __v_534: G = (__v_533 * __v_420);
+            let __v_535: G = G::from_u64(16777216);
+            let __v_536: G = (__v_535 * __v_421);
+            let __v_537: G = G::from_u64(4294967296);
+            let __v_538: G = (__v_537 * __v_422);
+            let __v_539: G = G::from_u64(1099511627776);
+            let __v_540: G = (__v_539 * __v_423);
+            let __v_541: G = G::from_u64(281474976710656);
+            let __v_542: G = (__v_541 * __v_424);
+            let __v_543: G = G::from_u64(72057594037927936);
+            let __v_544: G = (__v_543 * __v_425);
+            let __v_545: G = (__v_542 + __v_544);
+            let __v_546: G = (__v_540 + __v_545);
+            let __v_547: G = (__v_538 + __v_546);
+            let __v_548: G = (__v_536 + __v_547);
+            let __v_549: G = (__v_534 + __v_548);
+            let __v_550: G = (__v_532 + __v_549);
+            let __v_551: G = (__v_418 + __v_550);
+            let __v_552: G = G::from_u64(256);
+            let __v_553: G = (__v_552 * __v_438);
+            let __v_554: G = G::from_u64(65536);
+            let __v_555: G = (__v_554 * __v_439);
+            let __v_556: G = G::from_u64(16777216);
+            let __v_557: G = (__v_556 * __v_440);
+            let __v_558: G = G::from_u64(4294967296);
+            let __v_559: G = (__v_558 * __v_441);
+            let __v_560: G = G::from_u64(1099511627776);
+            let __v_561: G = (__v_560 * __v_442);
+            let __v_562: G = G::from_u64(281474976710656);
+            let __v_563: G = (__v_562 * __v_443);
+            let __v_564: G = G::from_u64(72057594037927936);
+            let __v_565: G = (__v_564 * __v_444);
+            let __v_566: G = (__v_563 + __v_565);
+            let __v_567: G = (__v_561 + __v_566);
+            let __v_568: G = (__v_559 + __v_567);
+            let __v_569: G = (__v_557 + __v_568);
+            let __v_570: G = (__v_555 + __v_569);
+            let __v_571: G = (__v_553 + __v_570);
+            let __v_572: G = (__v_437 + __v_571);
+            let __v_573: G = G::from_u64(256);
+            let __v_574: G = (__v_573 * __v_446);
+            let __v_575: G = G::from_u64(65536);
+            let __v_576: G = (__v_575 * __v_447);
+            let __v_577: G = G::from_u64(16777216);
+            let __v_578: G = (__v_577 * __v_448);
+            let __v_579: G = G::from_u64(4294967296);
+            let __v_580: G = (__v_579 * __v_449);
+            let __v_581: G = G::from_u64(1099511627776);
+            let __v_582: G = (__v_581 * __v_450);
+            let __v_583: G = G::from_u64(281474976710656);
+            let __v_584: G = (__v_583 * __v_451);
+            let __v_585: G = G::from_u64(72057594037927936);
+            let __v_586: G = (__v_585 * __v_452);
+            let __v_587: G = (__v_584 + __v_586);
+            let __v_588: G = (__v_582 + __v_587);
+            let __v_589: G = (__v_580 + __v_588);
+            let __v_590: G = (__v_578 + __v_589);
+            let __v_591: G = (__v_576 + __v_590);
+            let __v_592: G = (__v_574 + __v_591);
+            let __v_593: G = (__v_445 + __v_592);
+            let __v_594: G = G::from_u64(256);
+            let __v_595: G = (__v_594 * __v_471);
+            let __v_596: G = G::from_u64(65536);
+            let __v_597: G = (__v_596 * __v_472);
+            let __v_598: G = G::from_u64(16777216);
+            let __v_599: G = (__v_598 * __v_473);
+            let __v_600: G = G::from_u64(4294967296);
+            let __v_601: G = (__v_600 * __v_474);
+            let __v_602: G = G::from_u64(1099511627776);
+            let __v_603: G = (__v_602 * __v_475);
+            let __v_604: G = G::from_u64(281474976710656);
+            let __v_605: G = (__v_604 * __v_476);
+            let __v_606: G = G::from_u64(72057594037927936);
+            let __v_607: G = (__v_606 * __v_477);
+            let __v_608: G = (__v_605 + __v_607);
+            let __v_609: G = (__v_603 + __v_608);
+            let __v_610: G = (__v_601 + __v_609);
+            let __v_611: G = (__v_599 + __v_610);
+            let __v_612: G = (__v_597 + __v_611);
+            let __v_613: G = (__v_595 + __v_612);
+            let __v_614: G = (__v_470 + __v_613);
+            let __v_615: G = G::from_u64(256);
+            let __v_616: G = (__v_615 * __v_479);
+            let __v_617: G = G::from_u64(65536);
+            let __v_618: G = (__v_617 * __v_480);
+            let __v_619: G = G::from_u64(16777216);
+            let __v_620: G = (__v_619 * __v_481);
+            let __v_621: G = G::from_u64(4294967296);
+            let __v_622: G = (__v_621 * __v_482);
+            let __v_623: G = G::from_u64(1099511627776);
+            let __v_624: G = (__v_623 * __v_483);
+            let __v_625: G = G::from_u64(281474976710656);
+            let __v_626: G = (__v_625 * __v_484);
+            let __v_627: G = G::from_u64(72057594037927936);
+            let __v_628: G = (__v_627 * __v_485);
+            let __v_629: G = (__v_626 + __v_628);
+            let __v_630: G = (__v_624 + __v_629);
+            let __v_631: G = (__v_622 + __v_630);
+            let __v_632: G = (__v_620 + __v_631);
+            let __v_633: G = (__v_618 + __v_632);
+            let __v_634: G = (__v_616 + __v_633);
+            let __v_635: G = (__v_478 + __v_634);
+            let __v_636: G = G::from_u64(256);
+            let __v_637: G = (__v_636 * __v_493);
+            let __v_638: G = G::from_u64(65536);
+            let __v_639: G = (__v_638 * __v_494);
+            let __v_640: G = G::from_u64(16777216);
+            let __v_641: G = (__v_640 * __v_495);
+            let __v_642: G = G::from_u64(4294967296);
+            let __v_643: G = (__v_642 * __v_496);
+            let __v_644: G = G::from_u64(1099511627776);
+            let __v_645: G = (__v_644 * __v_497);
+            let __v_646: G = G::from_u64(281474976710656);
+            let __v_647: G = (__v_646 * __v_498);
+            let __v_648: G = G::from_u64(72057594037927936);
+            let __v_649: G = (__v_648 * __v_499);
+            let __v_650: G = (__v_647 + __v_649);
+            let __v_651: G = (__v_645 + __v_650);
+            let __v_652: G = (__v_643 + __v_651);
+            let __v_653: G = (__v_641 + __v_652);
+            let __v_654: G = (__v_639 + __v_653);
+            let __v_655: G = (__v_637 + __v_654);
+            let __v_656: G = (__v_492 + __v_655);
+            let __v_657: G = G::from_u64(256);
+            let __v_658: G = (__v_657 * __v_501);
+            let __v_659: G = G::from_u64(65536);
+            let __v_660: G = (__v_659 * __v_502);
+            let __v_661: G = G::from_u64(16777216);
+            let __v_662: G = (__v_661 * __v_503);
+            let __v_663: G = G::from_u64(4294967296);
+            let __v_664: G = (__v_663 * __v_504);
+            let __v_665: G = G::from_u64(1099511627776);
+            let __v_666: G = (__v_665 * __v_505);
+            let __v_667: G = G::from_u64(281474976710656);
+            let __v_668: G = (__v_667 * __v_506);
+            let __v_669: G = G::from_u64(72057594037927936);
+            let __v_670: G = (__v_669 * __v_507);
+            let __v_671: G = (__v_668 + __v_670);
+            let __v_672: G = (__v_666 + __v_671);
+            let __v_673: G = (__v_664 + __v_672);
+            let __v_674: G = (__v_662 + __v_673);
+            let __v_675: G = (__v_660 + __v_674);
+            let __v_676: G = (__v_658 + __v_675);
+            let __v_677: G = (__v_500 + __v_676);
+            let __v_678: G = G::from_u64(0);
+            let __v_679: G = G::from_u64(0);
+            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_678, __v_679, __v_354, __v_530, __v_551, __v_572, __v_593]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+            let __v_680: G = __r_arr[0];
+            let __v_681: G = __r_arr[1];
+            let __v_682: G = G::from_u64(0);
+            let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_357, __v_358, __v_34, __v_30, __v_62, __v_64, __v_59, __v_60, __v_57, __v_682, __v_680, __v_681, __v_530, __v_551, __v_572, __v_593, __v_614, __v_635, __v_656, __v_677]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+            let __v_683: G = __r_arr[0];
+            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+            let __v_684: G = __r_arr[0];
+            match __v_155.as_canonical_u64() {
+              _ => {
                 match __v_38.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
                     let __v_685: G = __r_arr[0];
                     let __v_686: G = G::from_u64(1);
                     let __v_687: G = G::from_u64(1);
@@ -19018,7 +19267,7 @@ fn aiur_fn_191(
     break '__mc_3 [__v_688];
   },
   1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_60, __v_688]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_60, __v_688]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
     let __v_689: G = __r_arr[0];
     break '__mc_3 [__v_689];
   },
@@ -19028,18 +19277,18 @@ fn aiur_fn_191(
 }
  };
                     let __v_689: G = __mc_out___mc_3[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_57, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_57, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
                     let __v_690: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_64, __v_690]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_64, __v_690]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
                     let __v_691: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_62, __v_691]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_62, __v_691]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
                     let __v_692: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_508, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_508, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
                     let __v_693: G = __r_arr[0];
                     let __v_694: G = G::from_u64(1);
                     let __v_695: G = G::from_u64(1);
                     let __v_696: G = { let __values: [G; 3] = [__v_694, __v_695, __v_695]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_693, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_693, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
                     let __v_697: G = __r_arr[0];
                     let __v_698: G = __r_arr[1];
                     let __v_699: G = __r_arr[2];
@@ -19100,31 +19349,31 @@ fn aiur_fn_191(
                     let __v_754: G = (__v_739 + __v_753);
                     let __v_755: G = (__v_737 + __v_754);
                     let __v_756: G = (__v_705 + __v_755);
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_713, __v_38, __v_40, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_713, __v_38, __v_40, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
                     let __v_757: G = __r_arr[0];
                     let __v_758: G = __r_arr[1];
                     let __v_759: G = G::from_u64(1);
                     let __v_760: G = G::from_u64(1);
                     let __v_761: G = { let __values: [G; 3] = [__v_759, __v_760, __v_760]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_46, __v_761]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_46, __v_761]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
                     let __v_762: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_758, __v_762]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_758, __v_762]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
                     let __v_763: G = __r_arr[0];
-                    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_763, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_763, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                     let __v_764: G = __r_arr[0];
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_764, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_764, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
                     let __v_765: G = __r_arr[0];
                     let __v_766: G = __r_arr[1];
                     let __v_767: G = (__v_685 + __v_155);
-                    let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
                     let __v_768: G = __r_arr[0];
                     let __v_769: G = G::from_u64(1);
                     if (__v_768 != __v_769) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_768.as_canonical_u64(), rhs: __v_769.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
                     let __v_770: G = __r_arr[0];
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_252]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_252]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
                     let __v_771: G = __r_arr[0];
                     let __v_772: G = (__v_770 - __v_771);
                     let __v_773: G = G::from_bool((__v_772 == G::ZERO));
@@ -19132,9 +19381,9 @@ fn aiur_fn_191(
                     if (__v_773 != __v_774) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_773.as_canonical_u64(), rhs: __v_774.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
                     let __v_775: G = __r_arr[0];
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
                     let __v_776: G = __r_arr[0];
                     let __v_777: G = (__v_775 - __v_776);
                     let __v_778: G = G::from_bool((__v_777 == G::ZERO));
@@ -19142,7 +19391,7 @@ fn aiur_fn_191(
                     if (__v_778 != __v_779) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_778.as_canonical_u64(), rhs: __v_779.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                     let __v_780: G = __r_arr[0];
                     let __v_781: G = (__v_780 - __v_685);
                     let __v_782: G = G::from_bool((__v_781 == G::ZERO));
@@ -19150,7 +19399,7 @@ fn aiur_fn_191(
                     if (__v_782 != __v_783) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_782.as_canonical_u64(), rhs: __v_783.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
                     let __v_784: G = __r_arr[0];
                     let __v_785: G = (__v_784 - __v_195);
                     let __v_786: G = G::from_bool((__v_785 == G::ZERO));
@@ -19158,7 +19407,7 @@ fn aiur_fn_191(
                     if (__v_786 != __v_787) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_786.as_canonical_u64(), rhs: __v_787.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
                     let __v_788: G = __r_arr[0];
                     let __v_789: G = G::from_u64(1);
                     if (__v_788 != __v_789) {
@@ -19170,7 +19419,7 @@ fn aiur_fn_191(
                     if (__v_791 != __v_792) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_791.as_canonical_u64(), rhs: __v_792.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_765, __v_766, __v_44, __v_735, __v_756, __v_62, __v_64, __v_57, __v_59, __v_60, __v_24, __v_26, __v_28, __v_359, __v_358, __v_34, __v_656, __v_677, __v_684, __v_155, __v_767, __v_757, __v_38, __v_46, __v_685]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_765, __v_766, __v_44, __v_735, __v_756, __v_62, __v_64, __v_57, __v_59, __v_60, __v_24, __v_26, __v_28, __v_359, __v_358, __v_34, __v_656, __v_677, __v_684, __v_155, __v_767, __v_757, __v_38, __v_46, __v_685]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
                     let __v_793: G = __r_arr[0];
                     break '__mc_1 [__v_793];
                   },
@@ -19419,25 +19668,25 @@ fn aiur_fn_191(
     if (__v_357 != __v_514) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: None });
     }
-    let __ret: [G; OUT_191] = [];
-    if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_204] = [];
+    if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_192: usize = 2;
-const IN_192: usize = 2;
-const OUT_192: usize = 1;
-fn aiur_fn_192(
-  inp: [G; IN_192],
+const INPUT_SIZE_205: usize = 2;
+const IN_205: usize = 2;
+const OUT_205: usize = 1;
+fn aiur_fn_205(
+  inp: [G; IN_205],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_192], ExecError> {
+) -> Result<[G; OUT_205], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -19445,8 +19694,8 @@ fn aiur_fn_192(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_192] = [__v_4];
-        if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_205] = [__v_4];
+        if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19456,15 +19705,15 @@ fn aiur_fn_192(
   })
 }
 
-const INPUT_SIZE_193: usize = 1;
-const IN_193: usize = 1;
-const OUT_193: usize = 1;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+const INPUT_SIZE_206: usize = 1;
+const IN_206: usize = 1;
+const OUT_206: usize = 1;
+fn aiur_fn_206(
+  inp: [G; IN_206],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], ExecError> {
+) -> Result<[G; OUT_206], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -19474,14 +19723,14 @@ fn aiur_fn_193(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_193] = [__v_4];
-        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_206] = [__v_4];
+        if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_193] = [__v_4];
-        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_206] = [__v_4];
+        if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19491,19 +19740,19 @@ fn aiur_fn_193(
   })
 }
 
-const INPUT_SIZE_194: usize = 2;
-const IN_194: usize = 2;
-const OUT_194: usize = 2;
-fn aiur_fn_194(
-  inp: [G; IN_194],
+const INPUT_SIZE_207: usize = 2;
+const IN_207: usize = 2;
+const OUT_207: usize = 2;
+fn aiur_fn_207(
+  inp: [G; IN_207],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_194], ExecError> {
+) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -19512,8 +19761,8 @@ fn aiur_fn_194(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_194] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_207] = [__v_4, __v_5];
+        if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19523,15 +19772,15 @@ fn aiur_fn_194(
   })
 }
 
-const INPUT_SIZE_195: usize = 1;
-const IN_195: usize = 1;
-const OUT_195: usize = 1;
-fn aiur_fn_195(
-  inp: [G; IN_195],
+const INPUT_SIZE_208: usize = 1;
+const IN_208: usize = 1;
+const OUT_208: usize = 1;
+fn aiur_fn_208(
+  inp: [G; IN_208],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_195], ExecError> {
+) -> Result<[G; OUT_208], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
@@ -19543,17 +19792,17 @@ fn aiur_fn_195(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_195] = [__v_6];
-        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_208] = [__v_6];
+        if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_6 + __v_7);
-        let __ret: [G; OUT_195] = [__v_8];
-        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_208] = [__v_8];
+        if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19563,15 +19812,15 @@ fn aiur_fn_195(
   })
 }
 
-const INPUT_SIZE_196: usize = 1;
-const IN_196: usize = 1;
-const OUT_196: usize = 1;
-fn aiur_fn_196(
-  inp: [G; IN_196],
+const INPUT_SIZE_209: usize = 1;
+const IN_209: usize = 1;
+const OUT_209: usize = 1;
+fn aiur_fn_209(
+  inp: [G; IN_209],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_196], ExecError> {
+) -> Result<[G; OUT_209], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19582,17 +19831,17 @@ fn aiur_fn_196(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_196] = [__v_5];
-        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_209] = [__v_5];
+        if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_5 + __v_6);
-        let __ret: [G; OUT_196] = [__v_7];
-        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_209] = [__v_7];
+        if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19602,15 +19851,15 @@ fn aiur_fn_196(
   })
 }
 
-const INPUT_SIZE_197: usize = 2;
-const IN_197: usize = 2;
-const OUT_197: usize = 1;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+const INPUT_SIZE_210: usize = 2;
+const IN_210: usize = 2;
+const OUT_210: usize = 1;
+fn aiur_fn_210(
+  inp: [G; IN_210],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_197], ExecError> {
+) -> Result<[G; OUT_210], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19627,17 +19876,17 @@ fn aiur_fn_197(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_197] = [__v_1];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_210] = [__v_1];
+        if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_197] = [__v_14];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_210] = [__v_14];
+        if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19647,15 +19896,15 @@ fn aiur_fn_197(
   })
 }
 
-const INPUT_SIZE_198: usize = 2;
-const IN_198: usize = 2;
-const OUT_198: usize = 1;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+const INPUT_SIZE_211: usize = 2;
+const IN_211: usize = 2;
+const OUT_211: usize = 1;
+fn aiur_fn_211(
+  inp: [G; IN_211],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_198], ExecError> {
+) -> Result<[G; OUT_211], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19665,17 +19914,17 @@ fn aiur_fn_198(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_198] = [__v_1];
-        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_211] = [__v_1];
+        if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_198] = [__v_7];
-        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_211] = [__v_7];
+        if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19685,28 +19934,28 @@ fn aiur_fn_198(
   })
 }
 
-const INPUT_SIZE_199: usize = 2;
-const IN_199: usize = 2;
-const OUT_199: usize = 1;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+const INPUT_SIZE_212: usize = 2;
+const IN_212: usize = 2;
+const OUT_212: usize = 1;
+fn aiur_fn_212(
+  inp: [G; IN_212],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_199], ExecError> {
+) -> Result<[G; OUT_212], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_199] = [__v_0];
-        if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_212] = [__v_0];
+        if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
@@ -19714,8 +19963,8 @@ fn aiur_fn_199(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_199] = [__v_7];
-            if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_212] = [__v_7];
+            if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -19727,15 +19976,15 @@ fn aiur_fn_199(
   })
 }
 
-const INPUT_SIZE_200: usize = 1;
-const IN_200: usize = 1;
-const OUT_200: usize = 1;
-fn aiur_fn_200(
-  inp: [G; IN_200],
+const INPUT_SIZE_213: usize = 1;
+const IN_213: usize = 1;
+const OUT_213: usize = 1;
+fn aiur_fn_213(
+  inp: [G; IN_213],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_200], ExecError> {
+) -> Result<[G; OUT_213], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
@@ -19749,17 +19998,17 @@ fn aiur_fn_200(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_200] = [__v_8];
-        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_213] = [__v_8];
+        if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_8 + __v_9);
-        let __ret: [G; OUT_200] = [__v_10];
-        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_213] = [__v_10];
+        if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19769,15 +20018,15 @@ fn aiur_fn_200(
   })
 }
 
-const INPUT_SIZE_201: usize = 1;
-const IN_201: usize = 1;
-const OUT_201: usize = 1;
-fn aiur_fn_201(
-  inp: [G; IN_201],
+const INPUT_SIZE_214: usize = 1;
+const IN_214: usize = 1;
+const OUT_214: usize = 1;
+fn aiur_fn_214(
+  inp: [G; IN_214],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_201], ExecError> {
+) -> Result<[G; OUT_214], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -19794,17 +20043,17 @@ fn aiur_fn_201(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_201] = [__v_11];
-        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_214] = [__v_11];
+        if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_11 + __v_12);
-        let __ret: [G; OUT_201] = [__v_13];
-        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_214] = [__v_13];
+        if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19814,19 +20063,19 @@ fn aiur_fn_201(
   })
 }
 
-const INPUT_SIZE_202: usize = 2;
-const IN_202: usize = 2;
-const OUT_202: usize = 4;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+const INPUT_SIZE_215: usize = 2;
+const IN_215: usize = 2;
+const OUT_215: usize = 4;
+fn aiur_fn_215(
+  inp: [G; IN_215],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_202], ExecError> {
+) -> Result<[G; OUT_215], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -19837,8 +20086,8 @@ fn aiur_fn_202(
     let __v_8: G = __loaded[5];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_202] = [__v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_215] = [__v_4, __v_5, __v_6, __v_7];
+        if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19848,15 +20097,15 @@ fn aiur_fn_202(
   })
 }
 
-const INPUT_SIZE_203: usize = 1;
-const IN_203: usize = 1;
-const OUT_203: usize = 1;
-fn aiur_fn_203(
-  inp: [G; IN_203],
+const INPUT_SIZE_216: usize = 1;
+const IN_216: usize = 1;
+const OUT_216: usize = 1;
+fn aiur_fn_216(
+  inp: [G; IN_216],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_203], ExecError> {
+) -> Result<[G; OUT_216], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
@@ -19871,17 +20120,17 @@ fn aiur_fn_203(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_203] = [__v_9];
-        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_216] = [__v_9];
+        if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(1);
         let __v_11: G = (__v_9 + __v_10);
-        let __ret: [G; OUT_203] = [__v_11];
-        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_216] = [__v_11];
+        if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19891,15 +20140,15 @@ fn aiur_fn_203(
   })
 }
 
-const INPUT_SIZE_204: usize = 1;
-const IN_204: usize = 1;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+const INPUT_SIZE_217: usize = 1;
+const IN_217: usize = 1;
+const OUT_217: usize = 1;
+fn aiur_fn_217(
+  inp: [G; IN_217],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_204], ExecError> {
+) -> Result<[G; OUT_217], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -19909,17 +20158,17 @@ fn aiur_fn_204(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_204] = [__v_4];
-        if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_217] = [__v_4];
+        if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_4 + __v_5);
-        let __ret: [G; OUT_204] = [__v_6];
-        if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_217] = [__v_6];
+        if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19929,28 +20178,28 @@ fn aiur_fn_204(
   })
 }
 
-const INPUT_SIZE_205: usize = 2;
-const IN_205: usize = 2;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+const INPUT_SIZE_218: usize = 2;
+const IN_218: usize = 2;
+const OUT_218: usize = 1;
+fn aiur_fn_218(
+  inp: [G; IN_218],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_205], ExecError> {
+) -> Result<[G; OUT_218], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_205] = [__v_0];
-        if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_218] = [__v_0];
+        if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
@@ -19959,8 +20208,8 @@ fn aiur_fn_205(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_205] = [__v_8];
-            if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_218] = [__v_8];
+            if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -19972,28 +20221,28 @@ fn aiur_fn_205(
   })
 }
 
-const INPUT_SIZE_206: usize = 2;
-const IN_206: usize = 2;
-const OUT_206: usize = 1;
-fn aiur_fn_206(
-  inp: [G; IN_206],
+const INPUT_SIZE_219: usize = 2;
+const IN_219: usize = 2;
+const OUT_219: usize = 1;
+fn aiur_fn_219(
+  inp: [G; IN_219],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_206], ExecError> {
+) -> Result<[G; OUT_219], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_206] = [__v_0];
-        if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_219] = [__v_0];
+        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
@@ -20004,8 +20253,8 @@ fn aiur_fn_206(
         let __v_10: G = __loaded[5];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_206] = [__v_10];
-            if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_219] = [__v_10];
+            if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -21059,6 +21308,71 @@ pub(crate) fn execute_generated(
       let __out = aiur_fn_206(__inp, record, io_buffer, false)?;
       return Ok(__out.to_vec());
     },
+    207u64 => {
+      let __inp: [G; IN_207] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_207(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    208u64 => {
+      let __inp: [G; IN_208] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_208(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    209u64 => {
+      let __inp: [G; IN_209] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_209(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    210u64 => {
+      let __inp: [G; IN_210] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_210(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    211u64 => {
+      let __inp: [G; IN_211] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_211(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    212u64 => {
+      let __inp: [G; IN_212] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_212(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    213u64 => {
+      let __inp: [G; IN_213] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_213(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    214u64 => {
+      let __inp: [G; IN_214] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_214(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    215u64 => {
+      let __inp: [G; IN_215] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_215(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    216u64 => {
+      let __inp: [G; IN_216] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_216(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    217u64 => {
+      let __inp: [G; IN_217] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_217(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    218u64 => {
+      let __inp: [G; IN_218] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_218(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    219u64 => {
+      let __inp: [G; IN_219] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_219(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
     _ => {
       return Err(ExecError::InvalidFunIdx(fun_idx));
     },
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs
index 720fce56..971969b5 100644
--- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs
+++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs
@@ -16,7 +16,6 @@
 //! proof/vk/claims byte into a Lean `G` and marshalled the whole
 //! buffer across FFI.
 
-use multi_stark::p3_field::PrimeCharacteristicRing;
 use rustc_hash::FxHashMap;
 
 use crate::aiur_multi_stark::execute_generated;
@@ -50,7 +49,15 @@ pub fn execute_multi_stark(
 /// byte blobs: channel 0 = proof, 1 = vk, 2 = claims, each registered
 /// under key `[0]` on its channel (one stream per channel). Mirrors
 /// the layout of `MultiStark.verifierInput` (`Ix/MultiStark.lean`).
-pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer {
+/// Generic over the outer field: the foreign (byte-limb) verifier
+/// toplevel takes the same advice layout over any `AiurField` (the
+/// KZG stage feeds it BLS12-381 scalars).
+pub fn verifier_io_buffer_in<F: aiur::AiurField>(
+  proof: &[u8],
+  vk: &[u8],
+  claims: &[u8],
+) -> IOBuffer<F> {
+  use multi_stark::traits::Algebra;
   // Measurement hook: dump the raw advice blobs for offline analysis
   // (vk encoding/activation studies) when IX_DUMP_RECURSION_IO is set
   // to a directory.
@@ -62,12 +69,19 @@ pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer {
   let mut io =
     IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() };
   for (channel, bytes) in
-    [(0u64, proof), (1, vk), (2, claims)].map(|(c, b)| (G::from_u64(c), b))
+    [(0u64, proof), (1, vk), (2, claims)].map(|(c, b)| (F::from_u64(c), b))
   {
-    let data: Vec<G> = bytes.iter().map(|b| G::from_u8(*b)).collect();
+    let data: Vec<F> = bytes.iter().map(|b| F::from_u8(*b)).collect();
     let len = data.len();
     io.data.insert(channel, data);
-    io.map.insert((channel, vec![G::ZERO]), IOKeyInfo { idx: 0, len });
+    io.map.insert(
+      (channel, vec![<F as Algebra<F>>::ZERO]),
+      IOKeyInfo { idx: 0, len },
+    );
   }
   io
 }
+
+pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer {
+  verifier_io_buffer_in::<G>(proof, vk, claims)
+}
diff --git a/docs/kzg-stage.md b/docs/kzg-stage.md
new file mode 100644
index 00000000..196a0805
--- /dev/null
+++ b/docs/kzg-stage.md
@@ -0,0 +1,271 @@
+# The KZG stage: wrapping the recursive verifier over BLS12-381
+
+Status: PHASES A–D COMPLETE, stage 3 in CI. The full pipeline runs on
+`Nat.add_comm` at 40 queries: stage 1 (IxVM on FRI) 2 s / 5 GiB; stage 2
+(FRI recursion on FRI) 48 s / 59 GiB, 3.4 MB proof; stage 3 (the foreign
+verifier on KZG over BLS12-381) 15 min / 81 GiB, **765 KB** proof verified
+natively in 0.13 s. The `aiur` CI benchmark carries all three stages plus
+the pipeline ledger. Remaining: Phase E (ceremony SRS loader, codegen'd Fr
+runner, per-circuit streamed witness, stage-2 tuning for the wrapped
+pair).
+
+## 1. Goal and architecture
+
+A third proof stage that ends the recursion with a constant-size,
+natively-verifiable proof:
+
+- **Stage 1 (kernel)**: IxVM claims proven by Aiur over Goldilocks,
+  FRI PCS. Many proofs, big.
+- **Stage 2 (recursive verifier)**: the `multiStark` Aiur toplevel over
+  Goldilocks/FRI verifies stage-1 proofs in-circuit. One proof,
+  megabytes (query-dominated).
+- **Stage 3 (KZG wrap, NEW)**: the same verifier *program*, compiled as
+  an Aiur circuit whose **outer field is the BLS12-381 scalar field
+  Fr**, proven under multi-stark's `KzgConfig`. It verifies one stage-2
+  proof. Inner-field (Goldilocks) arithmetic is emulated via the
+  byte-limb `GoldilocksForeign` module. Output: a kilobyte-scale KZG
+  proof — one G1 point per column commitment round + a handful of
+  witness points, no queries — verified natively in milliseconds
+  (2 pairings). KZG is TERMINAL: it is never verified in-circuit
+  (BLS12-381 has no efficient outer curve; that is a feature here, not
+  a bug — see multi-stark `docs/pcs-abstraction.md`).
+
+Field story: the stage-3 circuit's own arithmetic (constraints,
+lookups, logUp) is Fr. The stage-2 proof's Goldilocks arithmetic is
+emulated on bytes inside it. Fq (G1 coordinates, pairings) exists only
+in the native prover/verifier — never arithmetized anywhere.
+
+## 2. What is actually tied to Goldilocks today (survey)
+
+**Rust (`crates/aiur`)** — one alias each, everything written against
+them:
+
+- `lib.rs`: `pub type G = multi_stark::p3_goldilocks::Goldilocks`;
+  channel constants are `G::ZERO/ONE/TWO/…`.
+- `synthesis.rs`: `pub type AiurConfig = GoldilocksBlake3Config`.
+- Real field-specific content is small: `constraints.rs` builds
+  `(2^32)⁻¹` (and similar) as Goldilocks constants — recompute
+  generically; `vk_codec.rs` writes constants as 8-byte words —
+  parametrize the width; the gadget tables (`gadgets/bytes1`,
+  `bytes2`, `blake3`) are small-value lookup tables, field-agnostic.
+- Bytecode constants are bytes/counters/u64 wire words — they embed
+  canonically in any field ≥ 2^64.
+
+**Lean (`Ix/Aiur/Goldilocks.lean`)**: `G = {u : UInt64 // u < gSize}`,
+`G.extensionDegree = 2`. Used by the DSL elaborator, the bytecode
+interpreter, and witness helpers. This is a REAL structural dependence,
+not just hosting: source constants are capped at p_goldilocks (and
+`G.ofNat` silently wraps larger literals), and the interpreter's
+arithmetic wraps at p. DECIDED: this is the wrong factoring — fixed by
+Phase A′ below (constants over ℚ, field chosen at execution), which
+supersedes the earlier "out of scope" position.
+
+**The keystone observation**: the foreign toplevel's semantics are
+OUTER-FIELD-INDEPENDENT. Every `GoldilocksForeign` operation is
+byte-level (u8 gadgets, carry chains, sums < 2^11 that wrap in no
+large field), so it computes identical results over Fr and over
+Goldilocks itself — that is why the `fg_*` self-tests pass under
+today's Goldilocks interpreter. Consequently the ENTIRE foreign
+verifier can be developed, executed, and validated on the existing
+Goldilocks stack (no Lean interpreter changes); only PROVING needs Fr.
+
+## 3. Phases (each lands green)
+
+### Phase A — genericize `crates/aiur` over the field (behavioral no-op)
+
+Make the config a parameter: `G = Val<SC>` for
+`SC: StarkGenericConfig` (multi-stark's crate-owned traits, post
+`pcs-traits`), Goldilocks/FRI remaining the only instantiation.
+Mechanical for the bulk (`execute.rs`, `trace.rs`, `memory.rs`,
+`querymap.rs`, `bytecode.rs` are field-generic in spirit); the known
+field-specific spots:
+
+- gadget-internal constants (`(2^32)⁻¹` etc.) — build from
+  `G::from_u64(..).inverse()`;
+- vk codec constant width (8 bytes → per-field width);
+- challenger/transcript binding via the config (already abstract in
+  multi-stark);
+- `num_publics = 4·D` and stage-2 width derive from the config's
+  extension degree (D = 2 today, D = 1 under `KzgConfig` — multi-stark
+  already handles D = 1 first-class).
+
+**Gate**: kernel FFT pins + shard pin byte-identical; `ix codegen
+--check` clean. Same discipline as multi-stark's Phase 0 — the
+refactor is provably a no-op before anything builds on it.
+
+### Phase A′ — Lean constants as exact naturals [COMPLETE]
+
+Constants belong to the program, fields to the instantiation. Scoped to
+`Nat` (rationals deferred: any other constant kind requires compound
+operations anyway, and naturals keep specialization a single checked
+embedding):
+
+- **Elaborator**: numeric literals are exact `Nat`s — `G.ofNat`'s
+  silent mod-p wrap is gone from the source path.
+- **Source → bytecode**: `Term.field`/`Pattern.field`/`Op.const`/match
+  keys carry `Nat` through every stage.
+- **Specialization = checked embedding**, per consumer: a constant `≥ p`
+  is a hard ERROR — "the field cannot represent this circuit" — never a
+  wrap. Bonus: with the error in force, distinct keys stay distinct in
+  every accepted field, so no match-collision check is needed.
+  - Lean interpreters (`BytecodeEval`, `SourceEval`, `Interpret`):
+    on-the-fly `G.ofNat?` per use; overflow raises `constantOverflow`
+    (pattern keys: an unrepresentable constant matches no value).
+  - FFI (`lean_nat_as_field`): decodes scalar AND GMP-boxed Nats
+    (values in `[2^63, p)` are boxed), panics with the overflow message.
+  - Codegen: `checkConstants gSize` guard at emission
+    (`Bytecode.Toplevel.checkConstants`, off `Block.maxConstant`).
+- Runtime VALUES in the Lean interpreters are still per-field elements
+  (G today); "bytecode is field-free" does not mean "execution is". A
+  field-class-parametrized interpreter lands with the second Lean field
+  instance, if ever needed.
+
+**Gate held**: codegen byte-identical, kernel FFT + shard pins exact,
+all suites + Rust workspace tests green.
+
+### Phase B — the foreign verifier toplevel, validated over Goldilocks [COMPLETE]
+
+Swap the wire layer onto the inner-field interface and build
+`multiStarkForeign`:
+
+- `Deserialize.lean`: `type Ext = [G; 2]` → `[Goldilocks; 2]`; field
+  lanes stay bytes (`[U8; 8]`) instead of reducing to native — under
+  foreign, a wire limb already IS the representation, so ingest
+  (`gl_val`) is one conditional subtraction of p;
+- `limb_to_field` call sites (e.g. `ro_fold`) → `@gl_val`;
+- challenger egress `gl_to_bytes` = identity (cheaper than native);
+  rejection sampling (`gl_lt_p`) unchanged (byte logic);
+- `SystemDeserialize` vk-constant ingest → interface-typed (already
+  `@gl_val`);
+- toplevel: `…merge goldilocksForeign…` in place of
+  `goldilocksNative` (same names — exactly one merges, by design).
+
+**Gate**: EXECUTE `multiStarkForeign` under the existing Goldilocks
+interpreter against the same vectors the native verifier passes
+(factorial stage-2 proof accepted; tampered advice and tampered claim
+rejected). Full verifier correctness before any Fr machinery exists.
+
+### Phase C — cost checkpoint + the emulation design [LANDED]
+
+The risk, measured, then removed in three steps (all on `Nat.add_comm`'s
+40-query stage-1 proof, same blobs through both verifiers):
+
+1. **Call-site splicing** of the byte-limb ops put every `g_mul` body
+   (~930 u8 lookups) into its caller: 386k columns, 43 MB wrap proof.
+   → Inline wrappers over memoized `*_impl` circuits; byte primitives as
+   their own circuits; pointer-threaded values. Width 386k → 8.5k, wrap
+   proof 854 KB. But FFT cost stayed **6.5× native** (7.1e11 vs 1.1e11):
+   the carry chains (`add16`/`add8`/`sub8`) were 54% of it, 43M rows.
+2. **The large-field design** (outer field > p²): a Goldilocks value is
+   ONE outer element `< p`; ops compute exactly in the outer field and
+   reduce by CHECK — `x·y = q·p + r` with `q, r < p` (hinted by the new
+   `unconstrained_gl_divmod`, pinned by one degree-2 identity and two
+   8-byte range checks), `x + y`/`x + p − y` with a boolean `q`, the
+   inverse hinted (`unconstrained_gl_inverse`) and pinned by one mul.
+   Width **7,594 vs native 7,176 (6%)**; FFT cost **1.44e11 — 1.32×
+   native**; interpreter execution 12 s vs 7 s native (was 65 s); toy KZG
+   wrap **33 s / 763 KB** (was 21 min / 43 MB), with arkworks' `asm` and
+   `parallel` MSM/FFT enabled in multi-stark.
+   Soundness needs |F| > 2p²; the module still runs under Goldilocks
+   (hint `(0, v)`, degenerate but correct identities) for the self-tests
+   and the interpreter gate. Beware evaluation order in the outer field:
+   `x − y + p` wraps at `x − y`; `x + p − y` does not.
+3. Remaining knobs for kernel scale: fewer stage-2 queries for the wrapped
+   pair (stage-3 area is linear in them); lazy reduction in `eg_mul`
+   (`a0·b0 + 7·a1·b1 < 8p²` is still exact — 2 reductions instead of 7,
+   needs a 67-bit range check on q); a codegen'd Fr runner.
+
+### Phase D — KZG instantiation, end-to-end at toy scale [GATE PASSED]
+
+LANDED: the full stage-3 path at factorial scale. `AiurField` for
+`Scalar`; `AiurSystem::build_kzg`; the FFI surface (`AiurKzgSystem`:
+build with a dev SRS / `proveMultiStark` over raw advice blobs /
+native `verify`), with the toplevel decoder and advice-buffer builder
+generic over the field (`LeanField`, `verifier_io_buffer_in`). The
+`kzg-verifier` suite proves the FOREIGN verifier's acceptance of a
+factorial stage-2-style proof (3 inner queries) over Fr under
+`KzgConfig` and verifies it natively; a tampered wrap proof rejects.
+
+Measured (dev SRS 2^17, single-threaded, interpreter execution),
+after the Phase-C memoization + pointer representation: **wrap proof
+854 KB, prove ~6.5 min** for a 30 KB inner proof (~7.2k effective
+columns × ~112 B each — proof size is Θ(total width) under per-column
+KZG, constant in trace height; the pre-fix call-site splicing measured
+386k columns / 43 MB / 21 min). Truly kilobyte-scale terminal proofs
+remain a stage-4 (Plonkish, O(1) polynomials) property.
+
+Remaining in this phase:
+
+- Codegen: the foreign toplevel gets its own generated witness runner
+  over Fr (`aiur_multi_stark_foreign.rs` or similar) — witness
+  generation is native Rust Fr arithmetic, fast (today's interpreter
+  execution over Fr is a large share of the 21 min).
+- Parallel MSM/iFFT in the KZG prover (pulled forward from Phase E if
+  prove time stays the bottleneck).
+
+### Phase E — scale and productionize
+
+- Kernel-scale stage-2 proof wrapped end-to-end.
+- Ceremony SRS loader (`Srs` is bring-your-own; monomial powers-of-tau
+  only): Filecoin's 2^27 BLS12-381 setup is the likely fit — foreign
+  traces are much taller than the native verifier's ~2^21; truncate to
+  a power of two, `Srs::validate()` on load.
+- Parallel MSM/FFT in the KZG prover (ark parallel features) after
+  measuring.
+- Final parameter tuning across the stage-2/stage-3 boundary.
+
+## 3b. The generic verifier (mirrors `pcs-traits`)
+
+The Aiur verifier is structured like the Rust one: a core written against
+interface NAMES, plus one merged implementation per interface (exactly one,
+same names by design — the mechanism the native/foreign field pair always
+used). Interfaces and their current implementations:
+
+| interface | names the core refers to | implementations |
+|---|---|---|
+| Field (`Ix/MultiStark/Field/`) | `Val`, `Ext`; `val_zero/one/two/generator/two_adic_root`, `ext_w`; `val_add/sub/neg/mul/is_zero/inverse`, `ext_add/sub/neg/mul/inverse/div/eq`; `val_from_bytes`, `val_to_bytes`, `val_from_u16`, `bytes_lt_modulus` | `goldilocksNative` (`Val = G`), `goldilocksForeign` (Goldilocks in a large outer field) |
+| Pcs (`Ix/MultiStark/Pcs/`) | `Commitment`, `PcsProof`, `PcsParams`; `read_commitment_at`, `read_pcs_proof`, `read_vk_commitment`, `read_pcs_params`; `commitment_onto`, `snoc_commitment`, `pcs_empty_commitment`; `pcs_verify` | `pcsFri` (Blake3 Merkle MMCS + FRI) |
+| Transcript (`Ix/MultiStark/Transcript/`) | `ch_sample8/field/ext/bits`, `ch_observe_val`, `snoc_b8`, `b8_onto`, `limbs_onto`, `log_degrees_onto`, `accs_onto`, `rev_onto`, `seed_tag_onto` | `transcriptBlake3` (blake3 is fixed by design) |
+| Domain (`Ix/MultiStark/Domain.lean`) | `two_adic_gen`, `pow2`, `trace_vanishing`, `trace_selectors`, `ext_exp_pow2` | `twoAdicDomain` (shared by every PCS) |
+
+Assembly: `multiStarkFullOver field pcs` — `multiStark` = native × FRI,
+`multiStarkForeign` = foreign × FRI. The refactor was pinned as a semantic
+no-op: identical circuit widths (5072/2104, 5250/2344) and FFT costs on the
+saved 40-query proof (1.0888e11 / 1.4405e11); codegen re-emits only in
+function order; every suite green.
+
+## 4. Decision points and open questions
+
+- **C is a real checkpoint**: if the foreign circuit is prohibitive
+  even after the mitigations, the fallbacks are more aggressive
+  stage-2 parameter shifts (PoW-heavy, query-light) or, much further
+  out, a Plonkish frontend for the wrap (out of scope, noted in
+  multi-stark's doc as Phase 3).
+- **Declaration-level inlining** is the one Aiur-compiler change the
+  plan needs; it should land independently (Phase C) with the native
+  toplevel's codegen byte-identical as its gate.
+- **Prune-after-splice** (nice-to-have): `@`-referenced functions
+  currently survive pruning as empty deactivated circuits (217 vs 207
+  fns today — zero column cost, a few vk bytes). Splice-then-prune
+  would drop them; only worth doing if vk size ever matters.
+- **Lean-side Fr interpreter**: NOT needed for the plan (the
+  field-independence trick covers development; witness gen is Rust).
+  Optional later for parity testing.
+- **Stage-3 public input**: same existential statement shape as stage
+  2 — the stage-2 vk digest + claims digest, as Fr elements packing
+  digest bytes (`b3_pack`'s 4-bytes-per-element works in any field).
+
+## 5. Prerequisites already landed
+
+- multi-stark `pcs-traits`: crate-owned traits (Transcript, Domain,
+  Pcs, field layer with D = 1 first-class), byte-identical FRI under
+  the pin, `ark_adapter/` with `Scalar`(Fr)/`Radix2Coset`/
+  `Blake3Transcript`/`Srs`(+validate)/`KzgPcs`/`KzgConfig`, end-to-end
+  KZG prove/verify (1,781-byte two-circuit proof).
+- ix `kzg` branch: multi-stark bump to `pcs-traits`; Aiur DSL modules
+  de-imported (moduleless); the `g_*`/`eg_*` inner-field interface
+  (`GoldilocksNative.lean`) adopted across `Pcs.lean`/`Verifier.lean`
+  (zero raw inner-field arithmetic outside the interface); and
+  `GoldilocksForeign.lean` (byte-limb, recovered from pre-nativization
+  history), passing the `gl_ops_ref` vectors + boundary/root tests as
+  its own toplevel.
diff --git a/lakefile.lean b/lakefile.lean
index 7c1f43ca..1c66dacb 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -52,7 +52,9 @@ Cargo output is visible with `lake -v build`. -/
 def cargoArgs (testFfi : Bool := false) (net : Bool := false) : IO (Array String) := do
   -- IX_NO_PAR=1 disables parallel
   let ixNoPar ← IO.getEnv "IX_NO_PAR"
-  let mut features : Array String := #[]
+  -- kzg (the BLS12-381 terminal stage) is always on: the stage-3 FFI
+  -- surface (`AiurKzgSystem`) is part of the production pipeline.
+  let mut features : Array String := #["kzg"]
   if ixNoPar != some "1" then features := features.push "parallel"
   if net && !System.Platform.isOSX then features := features.push "net"
   if testFfi then features := features.push "test-ffi"